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

Revert "Merge branch 'feat/reader-low-res-first-then-sharpen'"

Browse Source 
This reverts commit eb0750051f, reversing
changes made to ce34974727.
This commit is contained in:
AskaEth committed 2026-11-06 18:33:05 +08:00
1 parent eb0750051f
commit bbc73635a6
4 files changed
+71 -745
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tuku/test/test_reader_membudget.c
+21 -235
View File
@@ -17,12 +17,7 @@
* B7b 回退路径：CMYK / Adam7 PNG / 1bpp BMP 走 stb，按旧门控占位
* B7c P1-1 旁路回归：截断 12MP JPEG / 3000×3000 24bpp 头-only BMP（判定 backend，
* 后端失败必须 NULL、峰值 ≤3MB）/ 非法位深 PNG（矩阵拒绝→stb 占位）
* B8 M27/M31：顺序连翻 100 页（101 页册，6 类循环，每页都是不同的下一页）不掉页、
* 不占位、存活增量 ≤3MB、绝对峰值有上界、预取命中 ≥90%、解码次数 ≤2/页+余量
* （M31 r2：修「每翻一页解 4 次」与高峰值，评审 P1-1/P1-2/P2-1/P2-3）
* B10 M31：两级清晰度生命周期（JPEG 大页）：低档先落位（open 不阻塞）→ 停稳后高档落
* 同一槽（总常驻不增加、槽位不空、本次操作增量 ≤3MB）→ 双击放大换清晰不重置缩放/平移
* → 拖动中强塞的高档请求被取消通道作废 → 整串解码次数有界
* B8 M27：连翻 30 页（6 类循环）不掉页、不占位、任何时刻存活增量 ≤3MB
* B9 M27：CMYK 回退页集成 —— 占位可重试且不崩
*
* 夹具：BMP/PNG 小夹具由本文件用 C 写；JPEG/PNG/BMP 大夹具由 python3+Pillow 生成
@@ -120,7 +115,6 @@ static int g_fail;
} while (0)
#define INFO(...) do { printf(" info: "); printf(__VA_ARGS__); printf("\n"); } while (0)
/* ------------------------------------------------------------------ */
/* 夹具写入 */
/* ------------------------------------------------------------------ */
@@ -221,14 +215,6 @@ static int copy_file(const char *src, const char *dst)
return ok ? 0 : -1;
}
/* 同一文件系统优先硬链接：多页册只是「同样的夹具当很多页」，101 页 × 12MP/BMP/PNG 真拷贝
* 要写几百 MB，跑一次测试 I/O 比解码还久（评审复跑成本）。读侧只按路径打开，硬链接完全等价。 */
static int link_or_copy(const char *src, const char *dst)
{
if (link(src, dst) == 0) return 0;
return copy_file(src, dst);
}
static int have_file(const char *path)
{
struct stat st;
@@ -475,23 +461,20 @@ int main(void)
}
int have_jpeg = gen_jpeg_fixtures(jpgbook);
/* 顺序连翻 100 页：6 类典型页循环（12MP / 4MP / baseline / 渐进 / PNG / BMP）。
* 每类都必须走后端且不占位——这是「修好了却用不上」的回归防线。
* M31 r2（评审 P2-1）：101 页顺序遍历（不是 30 页来回跳）——每次翻页都落到**不同的
* 下一页**，4MP/12MP 夹具都会真正成为焦点页并被解码/换清晰。 */
/* 连翻 30 页：6 类典型页循环（12MP / 4MP / baseline / 渐进 / PNG / BMP）。
* 每类都必须走后端且不占位——这是「修好了却用不上」的回归防线。 */
static const char *const g_mix[] = {
"base2000.jpg", "prog2000.jpg", "page1600.png",
"page1600.bmp", "mp4.jpg", "mp12.jpg",
};
const int mix_n = (int)(sizeof g_mix / sizeof g_mix[0]);
const int mixed_goal = 101; /* 100 次前翻 → 第 101 页（不回卷、不触发册间衔接） */
int mixed_pages = 0;
if (have_jpeg) {
for (int i = 0; i < mixed_goal; i++) {
for (int i = 0; i < 30; i++) {
char src[MR_PATH_MAX], dst[MR_PATH_MAX];
snprintf(src, sizeof src, "%s/%s", jpgbook, g_mix[i % mix_n]);
snprintf(dst, sizeof dst, "%s/p%03d_%s", mixed, i, g_mix[i % mix_n]);
if (link_or_copy(src, dst) == 0) mixed_pages++;
snprintf(dst, sizeof dst, "%s/p%02d_%s", mixed, i, g_mix[i % mix_n]);
if (copy_file(src, dst) == 0) mixed_pages++;
}
}
/* 回退路径集成：CMYK（4 分量）必须占位且不崩。 */
@@ -608,9 +591,6 @@ int main(void)
mr_reader_ui_failed_pages());
/* 取消/预取纪律：100 次翻页的解码次数必须有界（M20 实测曾 1.75× 浪费）。 */
CHECK(decodes <= 100 * 2, "decode count bounded over 100 flips (%d)", decodes);
/* M31：小页（480×640=0.3MP）不分档——低档只会多一次解码 + 落框，纯开销。 */
CHECK(mr_reader_ui_low_decodes() == 0,
"small pages stay single-tier (%d low decodes)", mr_reader_ui_low_decodes());
meow_view_page_pop();
pump_ms(200);
}
@@ -782,237 +762,43 @@ int main(void)
printf(" SKIP jpeg assertions: Pillow unavailable (python3 -c 'import PIL')\n");
}
/* ---- B8 M27/M31：顺序连翻 100 页（101 页册，6 类典型页循环）——不掉页、不占位、
* 峰值不增长、预取命中、解码次数有界 ----
* M31 起这些 1.3–12MP 的页走两级清晰度（低档先上屏、停稳换高档）。评审 P1:
* - 顺序前翻（每页都落到不同的下一页），4MP/12MP 夹具真正成为焦点页；
* - 断言语义翻页命中率（目标页已在槽）与解码次数上限，防止「每翻一页解 4 次」；
* - 存活增量仍按单页解码峰值封顶（两档共存时换清晰前会腾掉非可见页，见 reader.c）。 */
if (have_jpeg && mixed_pages == mixed_goal) {
/* ---- B8 M27：连翻 30 页（6 类典型页循环）——不掉页、不占位、峰值 ≤3MB ---- */
if (have_jpeg && mixed_pages == 30) {
mr_reader_ui_test_set_mem(4096, 16000);
mr_reader_open_dir(mixed);
pump_ms(1200);
CHECK(mr_reader_ui_count() == mixed_goal, "mixed book pages=%d", mr_reader_ui_count());
CHECK(mr_reader_ui_count() == 30, "mixed book pages=%d", mr_reader_ui_count());
int w = meow_ui_width();
int advanced = 0, skipped_max = 0;
size_t live_steady = g_live;
int d0 = mr_reader_ui_decode_count();
int low0 = mr_reader_ui_low_decodes(), high0 = mr_reader_ui_high_decodes();
int hits0 = mr_reader_ui_flip_hits(), miss0 = mr_reader_ui_flip_misses();
/* P2-3：只在窗口稳定后 reset 一次，之后不再 reset——这样淘汰旧图不会掩盖
* 「分配新图 + 解码」的真实峰值；指标 = 整个 100 翻窗口内相对稳态基线的最大存活增量。
* 「分配新图 + 解码」的真实峰值；指标 = 整个 30 翻窗口内相对稳态基线的最大存活增量。
* （旧实现每翻页 reset 一次，淘汰把基线拉低，报告里的 536KB 是伪值。） */
size_t base = peak_reset();
for (int i = 0; i < 100; i++) {
for (int i = 0; i < 30; i++) {
int before = mr_reader_ui_page();
tap(40, 300); /* RTL：左 1/3 = 下一页（顺序前翻） */
pump_ms(400); /* 700ms/页：给「换清晰→补邻居」留出余量 */
if (mr_reader_ui_page() == before + 1) advanced++;
tap(i % 2 == 0 ? 40 : w - 40, 300);
pump_ms(220);
if (mr_reader_ui_page() != before) advanced++;
if (mr_reader_ui_skipped_pages() > skipped_max)
skipped_max = mr_reader_ui_skipped_pages();
}
size_t transient = g_peak > base ? g_peak - base : 0;
int hits = mr_reader_ui_flip_hits() - hits0;
int miss = mr_reader_ui_flip_misses() - miss0;
int decodes = mr_reader_ui_decode_count() - d0;
INFO("100 mixed flips: advanced=%d last_page=%d hits=%d miss=%d skipped=%d decodes=%d "
"(low=%d high=%d) steady=%zuKB resident=%ldKB max_live_delta=%zuKB abs_peak=%zuKB",
advanced, mr_reader_ui_page(), hits, miss, skipped_max, decodes,
mr_reader_ui_low_decodes() - low0, mr_reader_ui_high_decodes() - high0,
live_steady / 1024, mr_reader_ui_resident_kb(), transient / 1024, g_peak / 1024);
CHECK(advanced == 100 && mr_reader_ui_page() == 100,
"100 次顺序前翻逐页推进（advanced=%d last=%d）", advanced, mr_reader_ui_page());
INFO("30 mixed flips: advanced=%d skipped=%d decodes=%d steady=%zuKB "
"resident=%ldKB max_live_delta=%zuKB",
advanced, skipped_max, mr_reader_ui_decode_count() - d0,
live_steady / 1024, mr_reader_ui_resident_kb(), transient / 1024);
CHECK(advanced == 30, "30 页全部翻到 (%d/30)", advanced);
CHECK(skipped_max == 0, "典型页连翻无占位 (max=%d)", skipped_max);
CHECK(mr_reader_ui_failed_pages() == 0, "无永久失败页 (%d)",
mr_reader_ui_failed_pages());
CHECK(mr_reader_ui_low_decodes() > low0 && mr_reader_ui_high_decodes() > high0,
"大页确实走了两级（low +%d, high +%d）",
mr_reader_ui_low_decodes() - low0, mr_reader_ui_high_decodes() - high0);
/* 顺序阅读的预取命中率：评审要求不低于基线 7/8。 */
CHECK(hits >= 90, "顺序翻页预取命中率 ≥90%%（hit=%d miss=%d）", hits, miss);
/* 解码次数上限：分档页 = 低档 + 高档（2 次/页），非 JPEG 单档（1 次/页）+ 开册/补邻居余量。
* 出现「每页 4 次」的放大（P1-2 的病灶）时这里会立刻失败。 */
CHECK(decodes <= 100 * 2 + 20, "100 次翻页解码次数 ≤2/页+余量 (decodes=%d)", decodes);
CHECK(mr_reader_ui_resident_kb() <= mr_reader_ui_resident_cap_kb(),
"常驻仍在上限内 (%ldKB ≤ %ldKB)", mr_reader_ui_resident_kb(),
mr_reader_ui_resident_cap_kb());
CHECK(transient <= 3 * 1024 * 1024,
"100 页连翻任何时刻存活增量 ≤3MB (%zuKB)", transient / 1024);
/* 两档共存的总账：常驻（≤3MB）+ 单次解码（≤3MB）——不许因为「基线里已含低档」
* 就看着没涨；绝对存活峰值同样要有上界。 */
CHECK(g_peak <= (size_t)(mr_reader_ui_resident_cap_kb() + 3 * 1024) * 1024,
"绝对存活峰值 ≤ 常驻上限+3MB (%zuKB)", g_peak / 1024);
"30 页连翻任何时刻存活增量 ≤3MB (%zuKB)", transient / 1024);
meow_view_page_pop();
pump_ms(200);
}
/* ---- B10 M31：两级清晰度生命周期（2000×3000 JPEG，真机同类大页）----
* 1) 冻结停稳窗口 → 只解低档：焦点页 tier=low、常驻=显示框大小（仍是一次原生 blit），
* 主线程不等解码（open 立即返回）；
* 2) 放开停稳窗口 → 高档落同一槽：tier=high、**总常驻不增加**（不是恒真的槽内字节比较）、
* 槽位全程不空、本次操作存活增量 ≤3MB、两档共存绝对峰值有上界；
* 3) 双击放大后按新几何先落低档，再换清晰 → 缩放/平移一字不差（P2-2）；
* 4) 拖动中强塞的高档请求 → 被 M22 的 gen/窗口取消通道作废（skip=cancel），不会被解出来；
* 5) 整串生命周期解码次数有界（P2-3）。 */
if (have_jpeg) {
char tierbook[MR_PATH_MAX];
snprintf(tierbook, sizeof tierbook, "%s/tier", root);
int tier_ok = mkdir_p(tierbook) == 0;
for (int i = 0; tier_ok && i < 2; i++) {
char src[MR_PATH_MAX], dst[MR_PATH_MAX];
snprintf(src, sizeof src, "%s/base2000.jpg", jpgbook);
snprintf(dst, sizeof dst, "%s/t%d.jpg", tierbook, i + 1);
if (link_or_copy(src, dst) != 0) tier_ok = 0;
}
if (tier_ok) {
mr_reader_ui_test_set_mem(4096, 16000);
mr_reader_ui_test_set_sharpen_ms(60000); /* 冻结：先验证低档先落位 */
uint64_t t_open = (uint64_t)meow_ui_time_ms();
mr_reader_open_dir(tierbook);
uint64_t open_ms = (uint64_t)meow_ui_time_ms() - t_open;
CHECK(mr_reader_ui_count() == 2, "tier book pages=%d", mr_reader_ui_count());
CHECK(open_ms < 500, "open is non-blocking (%llu ms)",
(unsigned long long)open_ms);
pump_ms(800);
meow_ui_paint_full();
int page0 = mr_reader_ui_page();
int dec0 = mr_reader_ui_decode_count();
CHECK(mr_reader_ui_focus_tier() == MR_TIER_LOW,
"low tier lands first (tier=%d)", mr_reader_ui_focus_tier());
CHECK(mr_reader_ui_low_decodes() >= 1, "low decode issued (%d)",
mr_reader_ui_low_decodes());
CHECK(mr_reader_ui_high_decodes() == 0,
"no high decode before the settle window (%d)", mr_reader_ui_high_decodes());
long low_kb = mr_reader_ui_slot_kb(page0);
CHECK(low_kb > 0, "low tier image resident (%ldKB)", low_kb);
long res_low = mr_reader_ui_resident_kb();
int bl = mr_reader_ui_blit_draws(), sc = mr_reader_ui_scaled_draws();
meow_ui_paint_full();
CHECK(mr_reader_ui_blit_draws() > bl && mr_reader_ui_scaled_draws() == sc,
"low tier draws as native blit (blit +%d, scaled +%d)",
mr_reader_ui_blit_draws() - bl, mr_reader_ui_scaled_draws() - sc);
/* 放开升级：边等边采样，焦点槽任何时刻都不能空（不闪白）。 */
int high0 = mr_reader_ui_high_decodes();
long min_slot = low_kb;
size_t op_base = g_live;
peak_reset();
mr_reader_ui_test_set_sharpen_ms(0);
for (int i = 0; i < 100 && mr_reader_ui_focus_tier() != MR_TIER_HIGH; i++) {
pump_ms(10);
long k = mr_reader_ui_slot_kb(page0);
if (k > 0 && k < min_slot) min_slot = k;
}
size_t op_peak = peak_since(op_base); /* 高档这一次操作的存活增量 */
meow_ui_paint_full();
CHECK(mr_reader_ui_page() == page0, "tier swap keeps the page (%d -> %d)",
page0, mr_reader_ui_page());
CHECK(mr_reader_ui_focus_tier() == MR_TIER_HIGH,
"high tier replaces low in the same slot (tier=%d)",
mr_reader_ui_focus_tier());
CHECK(mr_reader_ui_high_decodes() > high0,
"high decode issued after settle (%d -> %d)", high0,
mr_reader_ui_high_decodes());
/* P2-2：旧的 `slot_kb` 相等是恒真（两档都落同一个 box）。改成真正会抓问题的
* 「总常驻不增加」：如果换清晰偷偷多留一张低档，这里立刻涨。 */
long res_high = mr_reader_ui_resident_kb();
CHECK(res_high > 0 && res_high <= res_low,
"换清晰不增加常驻（没有第二张低档常驻）：%ldKB -> %ldKB",
res_low, res_high);
CHECK(op_peak <= 3 * 1024 * 1024,
"高档单次操作的存活增量 ≤3MB (%zuKB)", op_peak / 1024);
/* 两档共存总账：常驻 + 本次解码 的绝对峰值有上界（不是「基线含低档所以没涨」）。 */
CHECK(g_peak <= (size_t)(mr_reader_ui_resident_cap_kb() + 3 * 1024) * 1024,
"两档共存绝对峰值 ≤ 常驻上限+3MB (%zuKB)", g_peak / 1024);
CHECK(min_slot > 0, "no blank frame while swapping tiers (min slot %ldKB)",
min_slot);
CHECK(mr_reader_ui_scaled_draws() == sc,
"high tier still native blit (scaled %d -> %d)", sc,
mr_reader_ui_scaled_draws());
/* P2-2 之二：换清晰不得重置缩放/平移。先冻结窗口 → 双击放大（低档按新几何重解）
* → 记录缩放/平移 → 放开升级 → 高档落位后两者必须一字不差。 */
mr_reader_ui_test_set_sharpen_ms(60000); /* 先冻结，让放大后的低档先落位 */
reader_on_touch_down(240, 360);
reader_on_tap(240, 360);
pump_ms(60);
reader_on_touch_down(240, 360);
reader_on_tap(240, 360);
pump_ms(150);
pump_ms(600);
int zoom_before = mr_reader_ui_zoom_pct();
int panx_before = mr_reader_ui_pan_x();
int pany_before = mr_reader_ui_pan_y();
CHECK(zoom_before > 100, "double tap zoomed in (zoom=%d)", zoom_before);
CHECK(mr_reader_ui_focus_tier() == MR_TIER_LOW,
"zoomed page re-decodes to low tier first (tier=%d)",
mr_reader_ui_focus_tier());
mr_reader_ui_test_set_sharpen_ms(0);
for (int i = 0; i < 100 && mr_reader_ui_focus_tier() != MR_TIER_HIGH; i++)
pump_ms(10);
CHECK(mr_reader_ui_focus_tier() == MR_TIER_HIGH,
"zoomed page reaches the target tier (tier=%d)",
mr_reader_ui_focus_tier());
CHECK(mr_reader_ui_zoom_pct() == zoom_before &&
mr_reader_ui_pan_x() == panx_before &&
mr_reader_ui_pan_y() == pany_before,
"换清晰不重置缩放/平移（zoom %d→%d, pan %d,%d→%d,%d）",
zoom_before, mr_reader_ui_zoom_pct(), panx_before, pany_before,
mr_reader_ui_pan_x(), mr_reader_ui_pan_y());
/* 拖动中取消高档：拖动期间强塞一个「换清晰」请求，必须被取消通道作废。 */
int hd0 = mr_reader_ui_high_decodes(), hc0 = mr_reader_ui_high_canceled();
reader_on_touch_down(240, 400);
reader_on_touch_move(180, 400); /* 进入拖动 → g_sharpen_idx=-1 */
CHECK(mr_reader_ui_sharpen_idx() == -1, "drag clears sharpen eligibility");
mr_reader_ui_test_queue_high(page0);
pump_ms(200);
CHECK(mr_reader_ui_high_canceled() > hc0,
"high request canceled while dragging (%d -> %d)", hc0,
mr_reader_ui_high_canceled());
CHECK(mr_reader_ui_high_decodes() == hd0,
"canceled high request is never decoded (%d -> %d)", hd0,
mr_reader_ui_high_decodes());
reader_on_tap(240, 400); /* 松手：回弹，不翻页 */
pump_ms(300);
/* P2-2 之三：条漫滚动位置在换清晰时不得被重置（换的是视口中心页的档位）。 */
mr_reader_ui_test_set_sharpen_ms(60000); /* 先冻结：切模式时不要立刻换清晰 */
mr_reader_test_toggle_mode(); /* 翻页 → 条漫 */
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "tier book switched to webtoon");
pump_ms(300);
reader_on_touch_down(240, 600);
for (int k = 1; k <= 5; k++) {
reader_on_touch_move(240, 600 - k * 50);
pump_ms(10);
}
reader_on_tap(240, 300); /* 松手：fling */
pump_ms(2000); /* 等 fling 停稳 */
int woff0 = mr_reader_ui_woff();
int wpage0 = mr_reader_ui_page();
CHECK(woff0 > 0, "webtoon scrolled to a non-top offset (%d px)", woff0);
CHECK(mr_reader_ui_focus_tier() == MR_TIER_LOW,
"webtoon center page is low tier before settle (tier=%d)",
mr_reader_ui_focus_tier());
mr_reader_ui_test_set_sharpen_ms(0);
for (int i = 0; i < 200 && mr_reader_ui_focus_tier() != MR_TIER_HIGH; i++)
pump_ms(10);
CHECK(mr_reader_ui_focus_tier() == MR_TIER_HIGH,
"webtoon center page reaches the target tier (tier=%d)",
mr_reader_ui_focus_tier());
CHECK(mr_reader_ui_woff() == woff0 && mr_reader_ui_page() == wpage0,
"换清晰不重置条漫滚动位置（woff %d→%d, page %d→%d）",
woff0, mr_reader_ui_woff(), wpage0, mr_reader_ui_page());
mr_reader_ui_test_set_sharpen_ms(150); /* 恢复产品默认停稳窗口 */
/* P2-3：这一串（开册低+高、放大低+高、条漫低+高、一次被取消的高档）解码次数有界。 */
int decodes = mr_reader_ui_decode_count() - dec0;
CHECK(decodes <= 12, "两档生命周期解码次数有界 (decodes=%d)", decodes);
INFO("tier lifecycle: decodes=%d resident=%ldKB (低档/高档/放大/条漫 各一次换清晰)",
decodes, mr_reader_ui_resident_kb());
meow_view_page_pop();
pump_ms(200);
}
}
/* ---- B9 M27：回退路径集成 —— CMYK 页占位（可重试）且不崩 ---- */
if (have_fallback) {
mr_reader_ui_test_set_mem(4096, 16000);
tuku/test/test_reader_perf.c
+1 -45
View File
@@ -15,12 +15,7 @@
* P5 「先点适高，再切条漫」：scaled 不增长（评审点名的第二入口）；
* P6 双击放大再双击缩回：缩回后按新几何重解 → scaled 不增长（P2-1）；
* P7 静止若干帧不产生新解码（无重解抖动/活锁，P2-2）；
* P8 驻留页图有字节上界（<= 9MB）；
* P9 800×1280（评审表格另一档）：翻页 + 条漫都必须零重采样；
* P10 大屏（1080×1920）：fit 目标被字节上限钳住后不得反复重解；
* P11 分档策略（M31）：非 JPEG 大页不分档（一次解到目标档、仍是原生 blit）；
* 低档先落位→停稳换清晰→拖动取消的完整生命周期在 test_reader_membudget 的 B10
* 用真实 JPEG 夹具覆盖。
* P8 驻留页图有字节上界（<= 9MB）。
*
* 编译：test/run_tests.sh（与 test_open_book_host 同口径；只发布 meow_ui.a 时 SKIP）。
*/
@@ -373,45 +368,6 @@ int main(void)
"800x1280 webtoon: zero resample (scaled %d -> %d)", st,
mr_reader_ui_scaled_draws());
/* ---- P11 分档策略（M31）：非 JPEG 大页不分档——一次解到目标档，仍是原生 blit ----
* 低档/高档的完整生命周期（低档先落位→停稳换清晰→拖动取消）在 test_reader_membudget
* 的 B10 用真实 JPEG 夹具覆盖；这里只钉住「分档只给 JPEG」这条策略，防止把 PNG/BMP
* 也拖进未校准的「小图→落框」峰值路径。 */
{
char book3[MR_PATH_MAX];
snprintf(book3, sizeof book3, "./mr_perf_books_%ld/v3", (long)getpid());
int ok3 = mkdir_p(book3) == 0;
for (int i = 0; ok3 && i < 2; i++) {
char p[MR_PATH_MAX];
snprintf(p, sizeof p, "%s/t%d.bmp", book3, i + 1);
/* 1600×2400 = 3.84MP：量级与真机大页相同，但格式不是 JPEG。 */
if (write_bmp24(p, 1600, 2400, (unsigned)(i + 41)) != 0) ok3 = 0;
}
if (!ok3) {
printf(" SKIP: tier fixture write failed\n");
} else {
meow_view_page_pop(); /* 关掉 book2 */
uint64_t t_open = meow_ui_time_ms();
mr_reader_open_dir(book3);
uint64_t open_ms = meow_ui_time_ms() - t_open;
CHECK(mr_reader_ui_count() == 2, "tier book pages=%d", mr_reader_ui_count());
CHECK(open_ms < 500, "open returns without decoding on the UI thread (%llu ms)",
(unsigned long long)open_ms);
pump_ms(600);
draw_once();
CHECK(mr_reader_ui_focus_tier() == MR_TIER_HIGH,
"non-JPEG big page decodes straight to the target tier (tier=%d)",
mr_reader_ui_focus_tier());
CHECK(mr_reader_ui_low_decodes() == 0,
"no low tier for PNG/BMP (%d low decodes)", mr_reader_ui_low_decodes());
int bl = mr_reader_ui_blit_draws(), sc = mr_reader_ui_scaled_draws();
draw_once();
CHECK(mr_reader_ui_blit_draws() > bl && mr_reader_ui_scaled_draws() == sc,
"big BMP page draws as native blit (blit +%d, scaled +%d)",
mr_reader_ui_blit_draws() - bl, mr_reader_ui_scaled_draws() - sc);
}
}
meow_view_page_pop();
meow_view_free(reader);
meow_view_free(lib);