264 lines
10 KiB
C
264 lines
10 KiB
C
/* engine/rdft.c — FreeType 封装实现（见 engine/rdft.h）。
|
||
* 依赖 FreeType 2（静态篇 mipsel musl）；无 SDK 依赖。
|
||
*/
|
||
#include "rdft.h"
|
||
#include <ft2build.h>
|
||
#include FT_FREETYPE_H
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
typedef struct {
|
||
uint64_t key; /* (px<<32)|cp */
|
||
uint64_t stamp; /* LRU 时间戳 */
|
||
int adv; /* 水平 advance（px） */
|
||
uint8_t *bmp; /* 灰阶位图拷贝（malloc；bw==0 时 NULL） */
|
||
int bw, bh, pitch, left, top;
|
||
} glyph_slot;
|
||
|
||
/* advance 测量缓存：rdft_advance 逐字测量是排版索引用热路径（大书每次开/重排全量逐字测），
|
||
* 同一码点在全书反复出现（中文常用字 ~几千）。独立的小型开放寻址表缓存 (px,cp)→advance，
|
||
* 避免对重复码点反复 FT_Load_Glyph，把测量成本从 O(全书字符) 摊到 O(唯一码点)。
|
||
* 与 glyph_slot 缓存分离：glyph 缓存存「已光栅化位图」，此处只存 advance（不栅格化、不占位图）。 */
|
||
#define RD_ADV_SLOTS 4096 /* 幂 2；开放寻址线性探测 */
|
||
typedef struct { uint64_t key; int adv; } adv_slot;
|
||
|
||
struct rdft {
|
||
FT_Library lib;
|
||
FT_Face face;
|
||
int px;
|
||
glyph_slot *slots;
|
||
int nslots; /* 容量 */
|
||
int used; /* 在线条目数 */
|
||
uint64_t clock; /* 单调戳 */
|
||
adv_slot *adv; /* advance 缓存（排版测量） */
|
||
int has_font;
|
||
};
|
||
|
||
int rdft_init(rdft **r)
|
||
{
|
||
if (!r) return -1;
|
||
rdft *x = (rdft *)calloc(1, sizeof *x);
|
||
if (!x) return -6;
|
||
if (FT_Init_FreeType(&x->lib) != 0) { free(x); return -3; }
|
||
x->px = 20;
|
||
x->nslots = 512;
|
||
x->slots = (glyph_slot *)calloc((size_t)x->nslots, sizeof(glyph_slot));
|
||
if (!x->slots) { FT_Done_FreeType(x->lib); free(x); return -6; }
|
||
x->adv = (adv_slot *)calloc(RD_ADV_SLOTS, sizeof(adv_slot));
|
||
if (!x->adv) { free(x->slots); FT_Done_FreeType(x->lib); free(x); return -6; }
|
||
x->used = 0;
|
||
x->clock = 1;
|
||
*r = x;
|
||
return 0;
|
||
}
|
||
|
||
int rdft_load_font(rdft *r, const char *path)
|
||
{
|
||
if (!r || !path) return -1;
|
||
if (r->face) { FT_Done_Face(r->face); r->face = NULL; }
|
||
if (r->slots) { for (int i = 0; i < r->nslots; i++) free(r->slots[i].bmp); }
|
||
if (r->slots) memset(r->slots, 0, (size_t)r->nslots * sizeof(glyph_slot));
|
||
if (r->adv) memset(r->adv, 0, (size_t)RD_ADV_SLOTS * sizeof(adv_slot));
|
||
r->used = 0;
|
||
if (FT_New_Face(r->lib, path, 0, &r->face) != 0) { r->has_font = 0; return -1; }
|
||
r->has_font = 1;
|
||
if (r->px > 0) FT_Set_Pixel_Sizes(r->face, 0, r->px);
|
||
return 0;
|
||
}
|
||
|
||
void rdft_set_px(rdft *r, int px)
|
||
{
|
||
if (!r) return;
|
||
if (px <= 0) px = r->px;
|
||
r->px = px;
|
||
if (r->face) FT_Set_Pixel_Sizes(r->face, 0, (FT_UInt)px);
|
||
/* key 含字号，清缓存防旧字号位图残留（glyph + advance 同清，key 同含 px） */
|
||
if (r->slots) { for (int i = 0; i < r->nslots; i++) free(r->slots[i].bmp); memset(r->slots, 0, (size_t)r->nslots * sizeof(glyph_slot)); }
|
||
if (r->adv) memset(r->adv, 0, (size_t)RD_ADV_SLOTS * sizeof(adv_slot));
|
||
r->used = 0;
|
||
}
|
||
|
||
int rdft_ascender(rdft *r)
|
||
{
|
||
if (!r || !r->face) return 0;
|
||
return (int)(r->face->size->metrics.ascender >> 6);
|
||
}
|
||
int rdft_descender(rdft *r)
|
||
{
|
||
if (!r || !r->face) return 0;
|
||
return (int)(r->face->size->metrics.descender >> 6);
|
||
}
|
||
const char *rdft_family(rdft *r)
|
||
{
|
||
if (!r || !r->face || !r->face->family_name) return "";
|
||
return r->face->family_name;
|
||
}
|
||
|
||
static glyph_slot *slot_find(rdft *r, uint64_t key)
|
||
{
|
||
for (int i = 0; i < r->nslots; i++)
|
||
if (r->slots[i].key == key && r->slots[i].stamp) return &r->slots[i];
|
||
return NULL;
|
||
}
|
||
static glyph_slot *slot_lru_evict(rdft *r)
|
||
{
|
||
/* 找未用槽（stamp==0）或最旧使用 */
|
||
glyph_slot *oldest = NULL;
|
||
uint64_t mins = UINT64_MAX;
|
||
for (int i = 0; i < r->nslots; i++) {
|
||
if (!r->slots[i].stamp) { r->used++; return &r->slots[i]; } /* 空槽 */
|
||
if (r->slots[i].stamp < mins) { mins = r->slots[i].stamp; oldest = &r->slots[i]; }
|
||
}
|
||
free(oldest->bmp);
|
||
oldest->bmp = NULL; oldest->key = 0; oldest->stamp = 0;
|
||
return oldest;
|
||
}
|
||
|
||
int rdft_glyph(rdft *r, uint32_t cp, int *adv_x,
|
||
const uint8_t **bitmap, int *bw, int *bh, int *left, int *top)
|
||
{
|
||
if (!r || !r->face || !adv_x) return -1;
|
||
if (r->clock == UINT64_MAX) { r->clock = 1; } /* 时钟回绕（罕见） */
|
||
uint64_t key = ((uint64_t)(uint32_t)r->px << 32) | cp;
|
||
glyph_slot *s = slot_find(r, key);
|
||
if (s) {
|
||
s->stamp = r->clock++;
|
||
*adv_x = s->adv;
|
||
*bitmap = s->bmp; *bw = s->bw; *bh = s->bh; *left = s->left; *top = s->top;
|
||
return 0;
|
||
}
|
||
/* miss：光栅化 */
|
||
FT_UInt gi = FT_Get_Char_Index(r->face, cp);
|
||
if (r->px <= 0) FT_Set_Pixel_Sizes(r->face, 0, (FT_UInt)r->px);
|
||
if (FT_Load_Glyph(r->face, gi, FT_LOAD_RENDER | FT_LOAD_NO_HINTING | FT_LOAD_TARGET_LIGHT) != 0) {
|
||
/* 空字形（缺字）→ 仅 advance */
|
||
*adv_x = r->face->glyph->advance.x >> 6;
|
||
*bitmap = NULL; *bw = *bh = *left = *top = 0;
|
||
return 0;
|
||
}
|
||
FT_GlyphSlot g = r->face->glyph;
|
||
int a = (int)((g->advance.x >= 0 ? g->advance.x + 0x20 : g->advance.x - 0x20) >> 6);
|
||
if (a < 0) a = 0;
|
||
|
||
s = slot_lru_evict(r);
|
||
s->key = key; s->stamp = r->clock++; s->adv = a;
|
||
s->bmp = NULL; s->bw = 0; s->bh = 0; s->pitch = 0; s->left = 0; s->top = 0;
|
||
if (g->bitmap.buffer && g->bitmap.width > 0 && g->bitmap.rows > 0) {
|
||
int w = (int)g->bitmap.width, rows = (int)g->bitmap.rows, pitch = (int)g->bitmap.pitch;
|
||
uint8_t *b = (uint8_t *)malloc((size_t)w * (size_t)rows);
|
||
if (b) {
|
||
/* 紧凑拷贝（每行 = w 字节），blend 用 bw 作行步长 */
|
||
for (int r_ = 0; r_ < rows; r_++)
|
||
memcpy(b + (size_t)r_ * (size_t)w, g->bitmap.buffer + (size_t)r_ * (size_t)pitch, (size_t)w);
|
||
s->bmp = b; s->bw = w; s->bh = rows; s->pitch = w;
|
||
s->left = g->bitmap_left; s->top = g->bitmap_top;
|
||
}
|
||
}
|
||
*adv_x = s->adv;
|
||
*bitmap = s->bmp; *bw = s->bw; *bh = s->bh; *left = s->left; *top = s->top;
|
||
return 0;
|
||
}
|
||
|
||
/* (px,cp)→advance 缓存：开放寻址线性探测；key==0 为空槽哨兵（key=(px<<32)|cp，px≥1 恒非 0）。 */
|
||
static uint32_t adv_hash(uint64_t key)
|
||
{
|
||
/* 乘法散列取高位，把 64 位 key（px 在高位、cp 在低位）散布到 12 位表。 */
|
||
return (uint32_t)((key * 2654435761ULL) >> 22) & (RD_ADV_SLOTS - 1);
|
||
}
|
||
static int adv_find(const rdft *r, uint64_t key, int *adv)
|
||
{
|
||
uint32_t h = adv_hash(key);
|
||
for (uint32_t i = 0; i < RD_ADV_SLOTS; i++) {
|
||
uint32_t idx = (h + i) & (RD_ADV_SLOTS - 1);
|
||
uint64_t k = r->adv[idx].key;
|
||
if (k == 0) return 0;
|
||
if (k == key) { *adv = r->adv[idx].adv; return 1; }
|
||
}
|
||
return 0;
|
||
}
|
||
static void adv_put(rdft *r, uint64_t key, int adv)
|
||
{
|
||
uint32_t h = adv_hash(key);
|
||
for (uint32_t i = 0; i < RD_ADV_SLOTS; i++) {
|
||
uint32_t idx = (h + i) & (RD_ADV_SLOTS - 1);
|
||
if (r->adv[idx].key == 0 || r->adv[idx].key == key) {
|
||
r->adv[idx].key = key; r->adv[idx].adv = adv; return;
|
||
}
|
||
}
|
||
/* 表满：丢弃（下次未命中直接算） */
|
||
}
|
||
|
||
int rdft_advance(rdft *r, uint32_t cp, int *adv_x)
|
||
{
|
||
if (!r || !r->face || !adv_x) return -1;
|
||
uint64_t key = ((uint64_t)(uint32_t)r->px << 32) | cp;
|
||
if (adv_find(r, key, adv_x)) return 0;
|
||
FT_UInt gi = FT_Get_Char_Index(r->face, cp);
|
||
if (r->px <= 0) FT_Set_Pixel_Sizes(r->face, 0, (FT_UInt)r->px);
|
||
if (FT_Load_Glyph(r->face, gi, FT_LOAD_NO_HINTING | FT_LOAD_TARGET_LIGHT) != 0) {
|
||
int a = r->face->glyph->advance.x >> 6;
|
||
*adv_x = a;
|
||
adv_put(r, key, a);
|
||
return 0;
|
||
}
|
||
int a = (int)((r->face->glyph->advance.x >= 0 ? r->face->glyph->advance.x + 0x20
|
||
: r->face->glyph->advance.x - 0x20) >> 6);
|
||
a = a < 0 ? 0 : a;
|
||
*adv_x = a;
|
||
adv_put(r, key, a);
|
||
return 0;
|
||
}
|
||
|
||
void rdft_blend565(uint16_t *fb, int pitch_bytes, int tw, int th,
|
||
int x, int y, const uint8_t *bmp, int bw, int bh, int left, int top,
|
||
uint16_t fg565, uint16_t bg565)
|
||
{
|
||
if (!fb || !bmp || bw <= 0 || bh <= 0) return;
|
||
int fg_r = (fg565 >> 11) & 0x1F, fg_g = (fg565 >> 5) & 0x3F, fg_b = fg565 & 0x1F;
|
||
int bg_r = (bg565 >> 11) & 0x1F, bg_g = (bg565 >> 5) & 0x3F, bg_b = bg565 & 0x1F;
|
||
int start_x = x + left, base_y = y; /* y 为基线 */
|
||
int start_y = base_y - top;
|
||
int pitch_px = pitch_bytes / 2; /* 目标每行像素数 */
|
||
for (int row = 0; row < bh; row++) {
|
||
int ty = start_y + row;
|
||
if (ty < 0) continue;
|
||
if (ty >= th) break;
|
||
const uint8_t *src = bmp + (size_t)row * (size_t)bw; /* 紧凑：每行 bw */
|
||
for (int col = 0; col < bw; col++) {
|
||
int tx = start_x + col;
|
||
if (tx < 0) continue;
|
||
if (tx >= tw) break;
|
||
unsigned a = src[col];
|
||
if (a == 0) continue;
|
||
uint16_t *px = fb + (size_t)ty * (size_t)pitch_px + tx;
|
||
int r = (fg_r * a + bg_r * (255 - a)) / 255;
|
||
int g = (fg_g * a + bg_g * (255 - a)) / 255;
|
||
int b = (fg_b * a + bg_b * (255 - a)) / 255;
|
||
*px = (uint16_t)((r << 11) | (g << 5) | b);
|
||
}
|
||
}
|
||
}
|
||
|
||
void rdft_cache_set_slots(rdft *r, int slots)
|
||
{
|
||
if (!r || slots < 0 || slots == r->nslots) return;
|
||
glyph_slot *na = (glyph_slot *)calloc((size_t)(slots ? slots : 1), sizeof(glyph_slot));
|
||
if (!na) return;
|
||
for (int i = 0; i < r->nslots; i++) free(r->slots[i].bmp);
|
||
free(r->slots);
|
||
r->slots = na; r->nslots = (slots ? slots : 1); r->used = 0;
|
||
}
|
||
int rdft_cache_slots(rdft *r) { return r ? r->nslots : 0; }
|
||
int rdft_cache_used(rdft *r) { return r ? r->used : 0; }
|
||
|
||
void rdft_free(rdft *r)
|
||
{
|
||
if (!r) return;
|
||
if (r->slots) { for (int i = 0; i < r->nslots; i++) free(r->slots[i].bmp); }
|
||
free(r->slots);
|
||
free(r->adv);
|
||
if (r->face) FT_Done_Face(r->face);
|
||
if (r->lib) FT_Done_FreeType(r->lib);
|
||
free(r);
|
||
}
|