fix(sdk): 收编公开 SDK 仓独有改进（图片预算解码 + JPEG 解码期缩解），主仓成为唯一权威源

公开仓 ~/Proj/MeowOS-SDK 的 sdk/ 与主仓 patch_v2/sdk 无共同 git 历史（subtree split
重写了提交哈希，不做跨仓 merge/subtree pull），按内容逐文件裁决。公开仓侧的真增量只有
commit 21bffa1（图片预算解码）及其依赖；其余差异是公开仓的自包含打包（扁平 include/、
vendored 头与 meow_font.c）或主仓早已超越的旧快照。

一、取公开侧（纯追加，主仓该文件无独有改动）
- stb_image.h：新增 stbi_load_scaled / stbi_load_scaled_from_memory——JPEG 输出级按
  步长抽取行/列，整幅原尺寸输出缓冲从不物化；进升级 JPEG 各分量系数 IDCT 进像素平面后
  立即释放。scale<=1 与旧 API 等价，非 JPEG 忽略。主仓版本的 diff 全部是公开侧新增
  （无主仓独有 hunk），故整体替换。
- meow_ui_img.c：追加 img_pick_scale / img_finish_dim / meow_img_probe_file /
  meow_img_load_file_dim / meow_img_load_mem_dim。既有加载入口一字未改。
- include/meow_ui_image.h：追加上述三个公共声明。
- 新增 test_meow_img_budget.c + test_meow_img_budget_gen.py（--wrap malloc/free 打点
  统计瞬时峰值，B1-B9 覆盖矩阵）。

二、取主仓（公开侧为旧快照或自包含适配，并入会回退功能）
- meow_ui_ime.c / test_ime_fix.c：主仓 bug3 修复（IME 打开瞬间 200ms TAP 冷却窗 +
  drain/40ms/再 drain）及其回归用例为公开侧所无；公开侧同名文件不含该修复。
- meow_ui_input.c / meow_ui_internal.h：主仓 meow_input_touch_reset（drain 与叠加抑制
  进入沿共用）、FreeType 渲染/字形声明、meow_time_ms_from_parts。公开侧此三处无独有声明
  可并，取主仓即并集。
- meow_ui_gfx.c / meow_ui_sys.c / meow_cachegov.c：主仓时钟 ABI 根因修复（o32 time32，
  meow_ui_time.c 链接期接管 __clock_gettime*）已把这些文件的本地 now_ms 统一为
  meow_ui_time_ms()；公开侧仍是各自 clock_gettime，回落即回退根因修复。
- meow_ui_dialog.c / meow_select.c：主仓 MD3 后续（对话框按钮胶囊 MEOW_SHAPE_FULL、
  bottom sheet 顶角 28）晚于公开侧快照，公开侧等于旧版。
- include/meow_ui_font.h：主仓多出 FreeType 段与 stdint 自洽 include，公开侧缺。
- build_sdk.sh / build_sdk_host.sh：主仓含 FreeType vendor 裁剪构建、meow_ui_time TU、
  launcher meow_font.a 打包；公开侧为自包含重写，不回流。
- 其余 test_*.c：差异仅为编译配方注释（公开仓用 -Iinclude、无 meow_ui_time.c、标注
  「需主仓组件故公开仓跳过」等），对主仓目录布局不成立，不改。

三、不引入（vendored 副本 / 打包产物）
- meow_font.c、include/meow_font.h、include/meow_ipc.h、include/meow_notif.h：公开仓
  为自包含 vendored 副本（meow_font.c 与主仓 font/meow_font.c 逐字节相同），主仓已有
  权威源，复制会制造双源。

裁决说明（两边都改过的文件）：
- test_meow_ui_select.c：公开仓把 T1 探针从 x=10 改到 x=12（commit 432875d）。主仓 x=10
  在本树实测 6/6 PASS（容器卡左缘 8、文本左缘 24，x=10 已在卡内且避开圆角），无失败
  可修，故不跟进该改动，避免无谓 churn。
- 公开侧「meow_media_playctl」一类 API 名：仅出现在公开仓 vendored 头/文档，主仓
  sdk 无对应实现，未硬造。

四、验证（worktree / 分支 feat/sdk-absorb-public-deltas）
- build_sdk_host.sh --verify：0 warning / 0 error；成员清单 76 个（OBJS 32 +
  meow_font.o + freetype 43）一致，全部 ELF32 MIPS32 rel2 (o32)。
- nm 确认 meow_ui.a 导出 meow_img_probe_file / meow_img_load_file_dim /
  meow_img_load_mem_dim / stbi_load_scaled / stbi_load_scaled_from_memory。
- 宿主测试：对「未改动的 main SDK」跑同一套矩阵做基线对比，40 项同名结果逐项完全一致
  （22 PASS / 11 FAIL / 7 建链失败，失败项与失败计数一字不差）；本提交新增
  test_meow_img_budget 为 PASS。补充按各测试正确配方单编：test_meow_img_color、
  test_meow_lyric、test_meow_lyric_view、test_meow_ui_ft（显式传入 MiSans 字体）、
  test_umbrella 均通过/0 warning。
- 既有失败全部是 Termux 环境问题，与本次合并无关（基线同样失败）：/tmp 不可写导致
  mkdtemp/fopen/bind EACCES（config/vol/notif_open/notify_ipc/notify_integration/
  sb_collapse/overlay_suppress/input_keys），audiod 守护不在场（ui_audio_host），
  test_sdk_fixes 阻塞循环超时（基线同样 124）。
- hello_app 用新 meow_ui.a 重链成功（0 warning，静态 MIPS32r2），可执行文件
  471380→473636 字节（+2256，新解码路径）。

五、影响
meow_ui.a 内容变化（新增 4 个 MEOW_API + stb 解码路径改变）→ 需重编重链 hello / files /
reader / ncm 四 App 与 meow_launcherd。

patch_v2/sdk/stb_image.h

@@ -429,6 +429,14 @@ STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in
 // for stbi_load_from_file, file pointer is left pointing immediately after image
 #endif
 
+// 追加（MeowOS SDK M12）：JPEG 解码期降采样。scale>=2 时按 s 抽取输出行/列，
+// 不物化整幅原尺寸输出缓冲（*x,*y 返回 ceil(原尺寸/s)）。scale<=1 与
+// stbi_load / stbi_load_from_memory 完全等价；非 JPEG 格式忽略 scale。
+STBIDEF stbi_uc *stbi_load_scaled_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels, int scale);
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load_scaled      (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels, int scale);
+#endif
+
 #ifndef STBI_NO_GIF
 STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
 #endif
@@ -907,7 +915,7 @@ typedef struct
 
 #ifndef STBI_NO_JPEG
 static int      stbi__jpeg_test(stbi__context *s);
-static void    *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static void    *stbi__jpeg_load_ex(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int scale);
 static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
 #endif
 
@@ -1134,7 +1142,7 @@ STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_fli
                                          : stbi__vertically_flip_on_load_global)
 #endif // STBI_THREAD_LOCAL
 
-static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc, int jpeg_scale)
 {
    memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
    ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
@@ -1165,7 +1173,9 @@ static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int re
    // bytes matching expectations; these are prone to false positives, so
    // try them later
    #ifndef STBI_NO_JPEG
-   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
+   if (stbi__jpeg_test(s)) return stbi__jpeg_load_ex(s,x,y,comp,req_comp, ri, jpeg_scale);
+   #else
+   STBI_NOTUSED(jpeg_scale);
    #endif
    #ifndef STBI_NO_PNM
    if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp, ri);
@@ -1257,10 +1267,10 @@ static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int byt
 }
 #endif
 
-static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+static unsigned char *stbi__load_and_postprocess_8bit_ex(stbi__context *s, int *x, int *y, int *comp, int req_comp, int jpeg_scale)
 {
    stbi__result_info ri;
-   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8, jpeg_scale);
 
    if (result == NULL)
       return NULL;
@@ -1283,10 +1293,15 @@ static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x,
    return (unsigned char *) result;
 }
 
+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   return stbi__load_and_postprocess_8bit_ex(s, x, y, comp, req_comp, 1);
+}
+
 static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
 {
    stbi__result_info ri;
-   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16, 1);
 
    if (result == NULL)
       return NULL;
@@ -1409,6 +1424,19 @@ STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, i
    return result;
 }
 
+// 追加(M12)：JPEG 解码期降采样（见头文件声明）。非 JPEG 等价于 stbi_load。
+STBIDEF stbi_uc *stbi_load_scaled(char const *filename, int *x, int *y, int *comp, int req_comp, int scale)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   stbi_uc *result;
+   stbi__context s;
+   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_8bit_ex(&s,x,y,comp,req_comp, scale);
+   if (result) fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   fclose(f);
+   return result;
+}
 
 #endif //!STBI_NO_STDIO
 
@@ -1433,6 +1461,14 @@ STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, i
    return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
 }
 
+// 追加(M12)：JPEG 解码期降采样（见头文件声明）。非 JPEG 等价于 stbi_load_from_memory。
+STBIDEF stbi_uc *stbi_load_scaled_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp, int scale)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_8bit_ex(&s,x,y,comp,req_comp, scale);
+}
+
 STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
 {
    stbi__context s;
@@ -1982,6 +2018,7 @@ typedef struct
    int            nomore;      // flag if we saw a marker so must stop
 
    int            progressive;
+   int            scale;       // 追加(M12)：输出抽取步长，默认 1=原尺寸
    int            spec_start;
    int            spec_end;
    int            succ_high;
@@ -3092,6 +3129,12 @@ static void stbi__jpeg_finish(stbi__jpeg *z)
                z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
             }
          }
+         // 追加(M12)：该分量系数已全部 IDCT 进像素平面，立即释放，降低进升级 JPEG 的峰值
+         if (z->img_comp[n].raw_coeff) {
+            STBI_FREE(z->img_comp[n].raw_coeff);
+            z->img_comp[n].raw_coeff = 0;
+            z->img_comp[n].coeff = 0;
+         }
       }
    }
 }
@@ -3893,6 +3936,10 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
       unsigned int i,j;
       stbi_uc *output;
       stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
+      stbi_uc *rowbuf = NULL;   // 追加(M12)：整行临时缓冲，仅 dec>1 时使用
+      int dec = z->scale > 1 ? z->scale : 1;
+      int out_w = (z->s->img_x + dec - 1) / dec;
+      int out_h = (z->s->img_y + dec - 1) / dec;
 
       stbi__resample res_comp[4];
 
@@ -3918,13 +3965,19 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
          else                               r->resample = stbi__resample_row_generic;
       }
 
+      // 追加(M12)：dec>1 时整行先转成像素再按步长抽取，不物化整幅原尺寸输出缓冲
+      if (dec > 1) {
+         rowbuf = (stbi_uc *) stbi__malloc_mad2(n, z->s->img_x, 0);
+         if (!rowbuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+      }
+
       // can't error after this so, this is safe
-      output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
-      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+      output = (stbi_uc *) stbi__malloc_mad3(n, out_w, out_h, 1);
+      if (!output) { STBI_FREE(rowbuf); stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
 
       // now go ahead and resample
       for (j=0; j < z->s->img_y; ++j) {
-         stbi_uc *out = output + n * z->s->img_x * j;
+         stbi_uc *out;
          for (k=0; k < decode_n; ++k) {
             stbi__resample *r = &res_comp[k];
             int y_bot = r->ystep >= (r->vs >> 1);
@@ -3939,6 +3992,9 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
                   r->line1 += z->img_comp[k].w2;
             }
          }
+         // 追加(M12)：resample 状态机须逐行推进（上面已完成）；非采样行直接丢弃
+         if (dec > 1 && (j % (unsigned int) dec) != 0) continue;
+         out = (dec > 1) ? rowbuf : output + (size_t) n * out_w * j;
          if (n >= 3) {
             stbi_uc *y = coutput[0];
             if (z->s->img_n == 3) {
@@ -4016,16 +4072,27 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
                   for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
             }
          }
+         // 追加(M12)：rowbuf 已按整行转好像素，按步长抽取写入输出行
+         if (dec > 1) {
+            stbi_uc *dst = output + (size_t) n * out_w * (j / (unsigned int) dec);
+            unsigned int x;
+            for (x=0; x < (unsigned int) out_w; ++x) {
+               int c;
+               for (c=0; c < n; ++c)
+                  dst[(size_t) x * n + c] = rowbuf[(size_t) x * dec * n + c];
+            }
+         }
       }
+      STBI_FREE(rowbuf);
       stbi__cleanup_jpeg(z);
-      *out_x = z->s->img_x;
-      *out_y = z->s->img_y;
+      *out_x = out_w;
+      *out_y = out_h;
       if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
       return output;
    }
 }
 
-static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+static void *stbi__jpeg_load_ex(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int scale)
 {
    unsigned char* result;
    stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
@@ -4033,6 +4100,7 @@ static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int re
    memset(j, 0, sizeof(stbi__jpeg));
    STBI_NOTUSED(ri);
    j->s = s;
+   j->scale = scale;   // 追加(M12)：输出抽取步长
    stbi__setup_jpeg(j);
    result = load_jpeg_image(j, x,y,comp,req_comp);
    STBI_FREE(j);