AskaEth/MeowOS-SDK
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: 畸形 DHT 拒绝 + 渐进式 restart 重同步（M23 r1 P1-1/P1-2）

Browse Source 
P1-1（内存安全）：mj_huff_build 构造 9 位快表前校验规范码空间
（code + bits[l] > (1<<l) → 表非法），填表时再夹一道 <512 边界；mj_dht 失败
即返回 0 → 后端拒绝 → 回退 stb。此前过订阅 DHT（如「长度 2 的码 100 个」）会把
fast[512] 下标推到 12799，28~220 字节的畸形 JPEG 就栈溢出（ASan 实测
stack-buffer-overflow，非 ASan 直接 SIGSEGV/SIGBUS）。
回归：码长 1..4 × 符号数 3..255 共 1012 组畸形 DHT 全部后端拒绝、无崩溃；
「有效 JPEG + 注入坏 DHT」走拒绝 + 回退（不花屏）。

P1-2（能力）：三处扫描循环的区间重同步统一到 mj_boundary，**只在 total == rst
（编码器区间长度）时重同步**。原实现一见「over && marker∈D0..D7」就重同步，但熵码
位缓冲有最多 9 位前瞻，over 会在区间真正结束前 1~2 个 MCU 置位——提前重同步会丢掉
bitbuf 里本区间剩余块的有效比特，随即失步（渐进式 DC 扫描每块仅 ~1 bit，前瞻能跨过
整个 MCU）。这正是 Pillow restart_marker_blocks=1/2/3/4/5/8/16/64/200 的渐进式
100% 回退 stb（25.8MiB）的根因。另修 mj_restart 裸扫把 FF 00（数据字节 0xFF 的填充）
里的 00 误当 marker。
回归：9 个渐进式 + restart 夹具全部 BACKEND=1、峰值 1.86MiB（与无 restart 相同）、
与同编码无 restart 文件逐字节一致（mad=0.000）；baseline + restart 仍逐字节一致。

附带（评审 P2 两项，改动极小且已验证）：
- PNG 8bit gray/RGB 的 tRNS 透明接通（8bit 采样值在 tRNS 低字节），与 stb 逐点 alpha 一致；
- 拒绝 16bit 量化表（只属 12bit 精度；收下会让 F*qt 在 mj_accim 里 int32 溢出，UB）。
- meow_img_load_file_step 的 JPEG 走真缩解后端（PNG/BMP 暂留 stb：阅读器预算模型仍是
  M22「整幅物化」口径，待 M27 同步后放开）。

验证：ASan 构建全 PASS；test_meow_img_stream 111 项全 PASS；test_meow_img_budget /
test_meow_img_color 全 PASS；tuku run_tests.sh rc=0（zip 106 / cbz 296，含 membudget）、
run_webtoon_tests.sh rc=0；build_sdk.sh 零警告，MIPS32 rel2 目标码。
峰值不变（修复不增加分配）：2000x3000 baseline/progressive 1.86MiB、PNG 1.33MiB。
体积：meow_jpeg.o 17,284B + meow_png_stream.o 8,456B = 25.1KB。
This commit is contained in:
AskaEth committed 2026-11-05 22:39:09 +08:00
1 parent e9c0749609
commit 11a4fcd730
6 files changed
+377 -54
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

sdk/meow_jpeg.c
+68 -38
View File
@@ -148,21 +148,26 @@ typedef struct {
int valptr[17];
} mj_huff;
static void mj_huff_build(mj_huff *h)
/* 构造 9 位快表 + 规范码表。返回 0 = 表非法（过订阅/码空间越界），调用方必须拒绝该表。
* 过订阅输入（如「长度 2 的码有 100 个」）此前会让 code << shift 把快表下标推到 512 之外，
* 28~220 字节的畸形 JPEG 就能栈溢出 → 这里在填表前校验码空间，填表时再加一道下标边界。 */
static int mj_huff_build(mj_huff *h)
{
int code = 0, k = 0, l;
memset(h->fast, 0, sizeof h->fast);
h->maxcode[0] = -1;
for (l = 1; l <= 16; l++) {
int i;
if (code + h->bits[l] > (1 << l)) return 0; /* 码空间溢出：过订阅表 */
h->valptr[l] = k;
h->mincode[l] = code;
for (i = 0; i < h->bits[l]; i++) {
if (l <= 9) {
int shift = 9 - l, j;
unsigned short e = (unsigned short)((l << 8) | h->vals[k]);
int base = code << shift;
for (j = 0; j < (1 << shift); j++)
h->fast[(code << shift) | j] = e;
if ((base | j) < 512) h->fast[base | j] = e;
}
code++;
k++;
@@ -170,6 +175,7 @@ static void mj_huff_build(mj_huff *h)
h->maxcode[l] = h->bits[l] ? code - 1 : -1;
code <<= 1;
}
return 1;
}
static int mj_hdecode(mj_src *s, const mj_huff *h)
@@ -341,16 +347,12 @@ static int mj_dqt(mj_img *img, const unsigned char *d, int len)
int pq = d[p] >> 4, tq = d[p] & 15, i;
p++;
if (tq > 3) return 0;
if (pq == 0) {
if (p + 64 > len) return 0;
for (i = 0; i < 64; i++) img->qt[tq][mj_zigzag[i]] = d[p + i];
p += 64;
} else {
if (p + 128 > len) return 0;
for (i = 0; i < 64; i++)
img->qt[tq][mj_zigzag[i]] = (d[p + 2 * i] << 8) | d[p + 2 * i + 1];
p += 128;
}
/* 16bit 量化表只出现在 12bit 精度（本模块不支持）；收下会让 F*qt 在 mj_accum 里
* int32 溢出（UB）。直接拒绝 → 后端返回 0 → 回退 stb。 */
if (pq != 0) return 0;
if (p + 64 > len) return 0;
for (i = 0; i < 64; i++) img->qt[tq][mj_zigzag[i]] = d[p + i];
p += 64;
img->have_qt[tq] = 1;
}
return 1;
@@ -371,7 +373,7 @@ static int mj_dht(mj_img *img, const unsigned char *d, int len)
if (total > 256 || p + total > len) return 0;
for (i = 0; i < total; i++) h->vals[i] = d[p + i];
p += total;
mj_huff_build(h);
if (!mj_huff_build(h)) return 0; /* 过订阅/码空间越界：拒绝整段 → 回退 stb */
if (tc) img->have_ac[th] = 1; else img->have_dc[th] = 1;
}
}
@@ -558,7 +560,10 @@ static void mj_skip_entropy(mj_img *img)
}
}
/* 重启标记：对齐位缓冲并吃掉 RSTn，重置 DC 预测。 */
/* 重启标记：对齐位缓冲并吃掉 RSTn，重置 DC 预测。
*
* 裸扫时必须跳过 FF 00（数据字节 0xFF 的填充）：区间末尾的填充字节常常正好是 0xFF，
* 它在码流里写成 `FF 00 FF Dn`；把中间那个 00 当成 marker 会让扫描提前结束并失步。 */
static void mj_restart(mj_img *img)
{
mj_src *s = &img->src;
@@ -573,14 +578,47 @@ static void mj_restart(mj_img *img)
c = mj_raw(s);
if (c < 0) { s->over = 1; break; }
if (c != 0xFF) continue;
do { c = mj_raw(s); if (c < 0) { s->over = 1; break; } } while (c == 0xFF);
if (c < 0) break;
if (c >= 0xD0 && c <= 0xD7) break;
s->marker = c; s->over = 1;
break;
for (;;) {
c = mj_raw(s);
if (c < 0) { s->over = 1; break; }
if (c == 0xFF) continue; /* 填充 FF */
if (c >= 0xD0 && c <= 0xD7) goto rst_found;
if (c == 0x00) break; /* FF00 = 数据字节，继续扫 */
s->marker = c; s->over = 1; /* 别的 marker：熵段结束 */
goto rst_done;
}
if (s->over) break;
}
}
rst_found:
for (i = 0; i < img->ncomp; i++) img->c[i].pred = 0;
rst_done:
;
}
/* 区间边界处理（三处扫描循环共用）。返回：0 = 熵段结束（调用方退出扫描）；
* 1 = 继续；2 = 刚做过区间重同步（AC 扫描需清 EOBRUN）。
*
* 只在 total == rst（编码器的区间长度）时重同步。**不能**一看到 over&&RSTn 就重同步：
* 熵码位缓冲有最多 9 位前瞻，`over` 会在区间真正结束前 1~2 个 MCU 就被置位，
* 此时 bitbuf 里还压着本区间剩余块的有效比特——提前重同步会把它们丢掉并失步
* （渐进式 DC 扫描每块仅 ~1 bit，前瞻能跨过整个 MCU；这是 rst=2..200 花屏的根因）。
* 到达 total==rst 时，RSTn 要么已被前瞻吃掉（over/marker=RSTn，清掉即可），
* 要么还在流里（裸扫对齐）——mj_restart 两种都处理。 */
static int mj_boundary(mj_img *img, int *total)
{
mj_src *s = &img->src;
if (img->rst && *total == img->rst) {
mj_restart(img);
*total = 0;
return 2;
}
if (s->over) {
/* 前瞻已吃到 RSTn：本区间剩余块的有效比特还在 bitbuf 里，继续解。
* 只有「非 RST 的 marker」才是熵段真的结束（EOI/下一段的 DHT…）。 */
return (s->marker >= 0xD0 && s->marker <= 0xD7) ? 1 : 0;
}
return 1;
}
typedef struct {
@@ -600,12 +638,7 @@ static void mj_scan_seq(mj_img *img, const mj_scan *sc)
for (my = 0; my < mcus_y; my++) {
for (mx = 0; mx < mcus_x; mx++) {
int j;
if (img->rst && total == img->rst) {
if (img->src.over && !(img->src.marker >= 0xD0 && img->src.marker <= 0xD7)) return;
mj_restart(img);
total = 0;
}
if (img->src.over) return;
if (!mj_boundary(img, &total)) return;
if (single) {
mj_comp *c = &img->c[sc->ci[0]];
c->td = sc->td[0]; c->ta = sc->ta[0];
@@ -635,12 +668,9 @@ static void mj_scan_dc_prog(mj_img *img, const mj_scan *sc)
for (my = 0; my < mcus_y; my++) {
for (mx = 0; mx < mcus_x; mx++) {
int j;
if (img->rst && total == img->rst) {
if (img->src.over && !(img->src.marker >= 0xD0 && img->src.marker <= 0xD7)) return;
mj_restart(img);
total = 0;
if (!mj_boundary(img, &total)) {
return;
}
if (img->src.over) return;
if (single) {
mj_comp *c = &img->c[sc->ci[0]];
c->td = sc->td[0];
@@ -669,13 +699,9 @@ static void mj_scan_ac_prog(mj_img *img, const mj_scan *sc)
c->ta = sc->ta[0];
for (by = 0; by < c->oh; by++) {
for (bx = 0; bx < c->ow; bx++) {
if (img->rst && total == img->rst) {
if (img->src.over && !(img->src.marker >= 0xD0 && img->src.marker <= 0xD7)) return;
mj_restart(img);
total = 0;
eobrun = 0;
}
if (s->over) return;
int rb = mj_boundary(img, &total);
if (!rb) return;
if (rb == 2) eobrun = 0; /* 区间重同步：EOB 游程不能跨 RST */
if (eobrun > 0) {
eobrun--;
} else {
@@ -709,7 +735,9 @@ static void mj_scan_ac_prog(mj_img *img, const mj_scan *sc)
}
total++;
img->blocks++;
if (s->over) return;
/* 这里**不能**再 `if (s->over) return`：块末的位前瞻可能已吃掉本区间的 RSTn
* （over=1），必须留给下一轮 mj_boundary 做区间重同步，否则渐进式 + restart 的
* AC 扫描会在第一个区间边界处静默退出、把后续 RST 当独立 marker 跳过 → 失步。 */
}
}
}
@@ -838,6 +866,7 @@ static int mj_decode(mj_img *img, int maxdim, int *tw, int *th, unsigned char **
}
continue;
}
{
if (!img->progressive) {
mj_scan_seq(img, &sc);
} else if (sc.ss == 0) {
@@ -846,6 +875,7 @@ static int mj_decode(mj_img *img, int maxdim, int *tw, int *th, unsigned char **
if (sc.ns != 1) return 0;
mj_scan_ac_prog(img, &sc);
}
}
s->bitcnt = 0;
s->bitbuf = 0;
/* 一个熵段结束：位读取器可能已把下一个 marker 吃掉，回填给主循环，