claude-noether
9b1c106dc5
Closes the deblock matrix: adds the four bS=4 intra-strength loop
filters used at I-MB edges (and other boundaries where H.264
§8.7.2.1 forces boundary strength to 4). After this PR fourier
covers all 8 standard 8-bit 4:2:0 deblock combinations:
bS<4 bS=4
----- -----
luma_v ✓ (cycle 8 QPU) ✓ (CPU)
luma_h ✓ (CPU, PR #9) ✓ (CPU)
chrm_v ✓ (CPU, PR #10) ✓ (CPU)
chrm_h ✓ (CPU, PR #10) ✓ (CPU)
Scope:
- 4 new kernel enums (LV_INTRA=13, LH_INTRA=14, CV_INTRA=15,
CH_INTRA=16), all → CPU substrate in the recipe table.
- 4 new public dispatch fns + 4 recipe wrappers (defined via two
DEFINE_INTRA_DISPATCH / DEFINE_INTRA_RECIPE macros to keep the
boilerplate tight).
- 4 new extern decls for the vendored
ff_h264_{v,h}_loop_filter_{luma,chroma}_intra_neon symbols.
- C reference: tests/h264_intra_loop_filter_ref.c covers all four
orientations. Algorithm per H.264 §8.7.2.3:
Luma: per-side strong/weak filter selector
strong_p = (|p2-p0| < β) AND (|p0-q0| < (α>>2)+2)
strong_q = (|q2-q0| < β) AND (|p0-q0| < (α>>2)+2)
Strong updates p0/p1/p2 (and mirror); weak updates p0 only.
Chroma: always weak, only p0/q0 updated.
- daedalus_h264_deblock_meta is REUSED for intra dispatches; the
tc0[] field is ignored (bS=4 hardcodes the strength). Callers
can build a single edge list and route by kernel without an
extra struct.
- Test refactor: an intra_test_spec table + run_intra_test helper
drives all four orientations through one harness, keeping the
new test surface compact (~50 LOC for 4 kernels vs ~200 if each
had its own test_deblock_*_intra fn).
Verified on hertz (Pi 5 / V3D 7.1):
$ ./build/test_api_h264
=== Phase 8a API smoke: H.264 kernels via recipe dispatch ===
...
H.264 deblock luma v intra: 1024/1024 bytes bit-exact (100.0000%)
H.264 deblock luma h intra: 1024/1024 bytes bit-exact (100.0000%)
H.264 deblock chroma v intra: 256/256 bytes bit-exact (100.0000%)
H.264 deblock chroma h intra: 256/256 bytes bit-exact (100.0000%)
...
All 11 H.264 kernels bit-exact PASS — the deblock matrix is closed.
The bit-exact match on first try is meaningful for these kernels:
the strong/weak filter selector + per-side asymmetry would have
surfaced any sign / shift / rounding mistake immediately. The
C reference is now a usable spec checkpoint for the eventual QPU
shader work.
QPU shader follow-up: not in this PR. The intra path's 3-cell
per-side update + strong/weak branch is structurally more complex
than the bS<4 path that already has a V shader (v3d_h264deblock.spv).
Per the prior R-band logic for deblock, intra edges are < 20% of
total deblock work at typical bit-rates, so NEON-only at ~ 10 ns/edge
fits comfortably in the budget.
434 lines
18 KiB
C
434 lines
18 KiB
C
/*
|
||
* Phase 8a — H.264 kernels through the public API.
|
||
*
|
||
* Covers IDCT 4x4, IDCT 8x8, deblock luma vertical. Each kernel
|
||
* exercised through daedalus_recipe_dispatch_* and compared to
|
||
* the C reference. Recipe routes all 3 to CPU (per cycles 6+7+8
|
||
* verdicts).
|
||
*/
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <stdint.h>
|
||
#include <stddef.h>
|
||
#include <string.h>
|
||
|
||
#include "../include/daedalus.h"
|
||
|
||
extern void daedalus_h264_idct_add_ref(uint8_t *dst, int16_t *block, ptrdiff_t stride);
|
||
extern void daedalus_h264_idct8_add_ref(uint8_t *dst, int16_t *block, ptrdiff_t stride);
|
||
extern void daedalus_h264_h_loop_filter_luma_ref(uint8_t *pix, ptrdiff_t stride,
|
||
int alpha, int beta, int8_t tc0[4]);
|
||
extern void daedalus_h264_v_loop_filter_chroma_ref(uint8_t *pix, ptrdiff_t stride,
|
||
int alpha, int beta, int8_t tc0[4]);
|
||
extern void daedalus_h264_h_loop_filter_chroma_ref(uint8_t *pix, ptrdiff_t stride,
|
||
int alpha, int beta, int8_t tc0[4]);
|
||
extern void daedalus_h264_v_loop_filter_luma_intra_ref(uint8_t *pix, ptrdiff_t stride,
|
||
int alpha, int beta);
|
||
extern void daedalus_h264_h_loop_filter_luma_intra_ref(uint8_t *pix, ptrdiff_t stride,
|
||
int alpha, int beta);
|
||
extern void daedalus_h264_v_loop_filter_chroma_intra_ref(uint8_t *pix, ptrdiff_t stride,
|
||
int alpha, int beta);
|
||
extern void daedalus_h264_h_loop_filter_chroma_intra_ref(uint8_t *pix, ptrdiff_t stride,
|
||
int alpha, int beta);
|
||
extern void daedalus_h264_v_loop_filter_luma_ref(uint8_t *pix, ptrdiff_t stride,
|
||
int alpha, int beta, int8_t tc0[4]);
|
||
extern void daedalus_put_h264_qpel8_mc20_ref(uint8_t *dst, const uint8_t *src,
|
||
ptrdiff_t stride);
|
||
|
||
static uint64_t xs_state = 0xa11264ULL;
|
||
static inline uint64_t xs(void) {
|
||
uint64_t x = xs_state;
|
||
x ^= x << 13; x ^= x >> 7; x ^= x << 17;
|
||
return xs_state = x;
|
||
}
|
||
|
||
static int test_idct4(void)
|
||
{
|
||
enum { N = 64, STRIDE = 64, BYTES = 8 * STRIDE };
|
||
daedalus_ctx *ctx = daedalus_ctx_create();
|
||
if (!ctx) return 1;
|
||
|
||
int16_t coeffs[N * 16], coeffs_ref[N * 16];
|
||
uint8_t dst[BYTES], dst_ref[BYTES];
|
||
daedalus_h264_block_meta meta[N];
|
||
|
||
/* Layout: 8x8 grid of 4x4 blocks (each 4x4 occupies 4 rows x 4 cols).
|
||
* Block (bx, by) at byte offset by*4*STRIDE + bx*4. Need BYTES big
|
||
* enough: 8 row-blocks * 4 rows = 32 rows × 64 stride = 2048. Use
|
||
* 8 row-blocks. */
|
||
enum { BX = 8, BY = 8, FULL_BYTES = BY * 4 * STRIDE };
|
||
uint8_t big_dst[FULL_BYTES], big_dst_ref[FULL_BYTES];
|
||
for (int i = 0; i < FULL_BYTES; i++)
|
||
big_dst[i] = big_dst_ref[i] = (uint8_t)(xs() & 0xff);
|
||
|
||
for (int i = 0; i < N * 16; i++) coeffs_ref[i] = coeffs[i] = (int16_t)((int)(xs() % 1024) - 512);
|
||
|
||
for (int by = 0; by < BY; by++) for (int bx = 0; bx < BX; bx++) {
|
||
int i = by * BX + bx;
|
||
meta[i].dst_off = by * 4 * STRIDE + bx * 4;
|
||
}
|
||
|
||
for (int i = 0; i < N; i++)
|
||
daedalus_h264_idct_add_ref(big_dst_ref + meta[i].dst_off,
|
||
coeffs_ref + i * 16, STRIDE);
|
||
|
||
int rc = daedalus_recipe_dispatch_h264_idct4(ctx, big_dst, STRIDE,
|
||
coeffs, N, meta);
|
||
if (rc) { fprintf(stderr, "idct4 dispatch rc=%d\n", rc); return 1; }
|
||
int diff = 0;
|
||
for (int i = 0; i < FULL_BYTES; i++) if (big_dst[i] != big_dst_ref[i]) diff++;
|
||
printf(" H.264 IDCT 4x4: %d/%d bytes bit-exact (%.4f%%)\n",
|
||
FULL_BYTES - diff, FULL_BYTES, 100.0 * (FULL_BYTES - diff) / FULL_BYTES);
|
||
daedalus_ctx_destroy(ctx);
|
||
return diff == 0 ? 0 : 1;
|
||
}
|
||
|
||
static int test_idct8(void)
|
||
{
|
||
enum { N = 16, STRIDE = 64, BYTES = (8 * 4) * STRIDE };
|
||
daedalus_ctx *ctx = daedalus_ctx_create();
|
||
if (!ctx) return 1;
|
||
|
||
int16_t coeffs[N * 64], coeffs_ref[N * 64];
|
||
uint8_t dst[BYTES], dst_ref[BYTES];
|
||
daedalus_h264_block_meta meta[N];
|
||
|
||
for (int i = 0; i < BYTES; i++) dst[i] = dst_ref[i] = (uint8_t)(xs() & 0xff);
|
||
for (int i = 0; i < N * 64; i++) coeffs_ref[i] = coeffs[i] = (int16_t)((int)(xs() % 2048) - 1024);
|
||
|
||
/* 8 blocks per row × 4 row-blocks = 32 blocks. Use 8 cols × 2 rows-of-blocks
|
||
* for safety inside BYTES. Actually BYTES = 32*64 = 2048, supports 8*8=64
|
||
* blocks. Let me use 8 cols × 2 rows of blocks = 16 blocks. */
|
||
int BX = 8, BY = 2; /* 16 blocks total */
|
||
for (int by = 0; by < BY; by++) for (int bx = 0; bx < BX; bx++) {
|
||
int i = by * BX + bx;
|
||
meta[i].dst_off = by * 8 * STRIDE + bx * 8;
|
||
}
|
||
|
||
for (int i = 0; i < N; i++)
|
||
daedalus_h264_idct8_add_ref(dst_ref + meta[i].dst_off,
|
||
coeffs_ref + i * 64, STRIDE);
|
||
|
||
int rc = daedalus_recipe_dispatch_h264_idct8(ctx, dst, STRIDE,
|
||
coeffs, N, meta);
|
||
if (rc) { fprintf(stderr, "idct8 dispatch rc=%d\n", rc); return 1; }
|
||
int diff = 0;
|
||
for (int i = 0; i < BYTES; i++) if (dst[i] != dst_ref[i]) diff++;
|
||
printf(" H.264 IDCT 8x8: %d/%d bytes bit-exact (%.4f%%)\n",
|
||
BYTES - diff, BYTES, 100.0 * (BYTES - diff) / BYTES);
|
||
daedalus_ctx_destroy(ctx);
|
||
return diff == 0 ? 0 : 1;
|
||
}
|
||
|
||
static int test_deblock(void)
|
||
{
|
||
/* One edge per 16x16 tile. */
|
||
enum { N_EDGES = 8, TILE_STRIDE = 16, TILE_BYTES = 16 * TILE_STRIDE,
|
||
TOTAL = N_EDGES * TILE_BYTES, EDGE_ROW = 4, EDGE_OFF = EDGE_ROW * TILE_STRIDE };
|
||
daedalus_ctx *ctx = daedalus_ctx_create();
|
||
if (!ctx) return 1;
|
||
|
||
uint8_t dst[TOTAL], dst_ref[TOTAL];
|
||
daedalus_h264_deblock_meta meta[N_EDGES];
|
||
|
||
for (int i = 0; i < TOTAL; i++) dst[i] = dst_ref[i] = (uint8_t)(xs() & 0xff);
|
||
for (int i = 0; i < N_EDGES; i++) {
|
||
meta[i].dst_off = i * TILE_BYTES + EDGE_OFF;
|
||
meta[i].alpha = (int)(xs() % 64) + 1;
|
||
meta[i].beta = (int)(xs() % 16) + 1;
|
||
for (int s = 0; s < 4; s++) {
|
||
int r = (int)(xs() % 8);
|
||
meta[i].tc0[s] = (int8_t)(r == 0 ? -1 : (r - 1));
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < N_EDGES; i++) {
|
||
int8_t tc0_local[4] = { meta[i].tc0[0], meta[i].tc0[1], meta[i].tc0[2], meta[i].tc0[3] };
|
||
daedalus_h264_v_loop_filter_luma_ref(dst_ref + meta[i].dst_off, TILE_STRIDE,
|
||
meta[i].alpha, meta[i].beta, tc0_local);
|
||
}
|
||
|
||
int rc = daedalus_recipe_dispatch_h264_deblock_luma_v(ctx, dst, TILE_STRIDE,
|
||
N_EDGES, meta);
|
||
if (rc) { fprintf(stderr, "deblock dispatch rc=%d\n", rc); return 1; }
|
||
int diff = 0;
|
||
for (int i = 0; i < TOTAL; i++) if (dst[i] != dst_ref[i]) diff++;
|
||
printf(" H.264 deblock luma v: %d/%d bytes bit-exact (%.4f%%)\n",
|
||
TOTAL - diff, TOTAL, 100.0 * (TOTAL - diff) / TOTAL);
|
||
daedalus_ctx_destroy(ctx);
|
||
return diff == 0 ? 0 : 1;
|
||
}
|
||
|
||
static int test_deblock_h(void)
|
||
{
|
||
/* Mirror of test_deblock but for the H variant. Per-tile layout
|
||
* is now 8 cols x 16 rows (one vertical edge between cols 3 and 4
|
||
* of the tile); EDGE_COL = 4 puts dst_off at the leftmost output
|
||
* column of the right block so the kernel's pix[-4..+3] read sits
|
||
* inside the tile. */
|
||
enum { N_EDGES = 8, TILE_STRIDE = 8, TILE_ROWS = 16,
|
||
TILE_BYTES = TILE_STRIDE * TILE_ROWS,
|
||
TOTAL = N_EDGES * TILE_BYTES, EDGE_COL = 4 };
|
||
daedalus_ctx *ctx = daedalus_ctx_create();
|
||
if (!ctx) return 1;
|
||
|
||
uint8_t dst[TOTAL], dst_ref[TOTAL];
|
||
daedalus_h264_deblock_meta meta[N_EDGES];
|
||
|
||
for (int i = 0; i < TOTAL; i++) dst[i] = dst_ref[i] = (uint8_t)(xs() & 0xff);
|
||
for (int i = 0; i < N_EDGES; i++) {
|
||
meta[i].dst_off = i * TILE_BYTES + EDGE_COL;
|
||
meta[i].alpha = (int)(xs() % 64) + 1;
|
||
meta[i].beta = (int)(xs() % 16) + 1;
|
||
for (int s = 0; s < 4; s++) {
|
||
int r = (int)(xs() % 8);
|
||
meta[i].tc0[s] = (int8_t)(r == 0 ? -1 : (r - 1));
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < N_EDGES; i++) {
|
||
int8_t tc0_local[4] = { meta[i].tc0[0], meta[i].tc0[1], meta[i].tc0[2], meta[i].tc0[3] };
|
||
daedalus_h264_h_loop_filter_luma_ref(dst_ref + meta[i].dst_off, TILE_STRIDE,
|
||
meta[i].alpha, meta[i].beta, tc0_local);
|
||
}
|
||
|
||
int rc = daedalus_recipe_dispatch_h264_deblock_luma_h(ctx, dst, TILE_STRIDE,
|
||
N_EDGES, meta);
|
||
if (rc) { fprintf(stderr, "deblock_h dispatch rc=%d\n", rc); return 1; }
|
||
int diff = 0;
|
||
for (int i = 0; i < TOTAL; i++) if (dst[i] != dst_ref[i]) diff++;
|
||
printf(" H.264 deblock luma h: %d/%d bytes bit-exact (%.4f%%)\n",
|
||
TOTAL - diff, TOTAL, 100.0 * (TOTAL - diff) / TOTAL);
|
||
daedalus_ctx_destroy(ctx);
|
||
return diff == 0 ? 0 : 1;
|
||
}
|
||
|
||
static int test_deblock_chroma_v(void)
|
||
{
|
||
/* Chroma V: per-tile 8 cols × 4 rows, edge between rows 1 and 2
|
||
* (EDGE_ROW=2 lets the kernel read pix[-2..+1]*stride safely). */
|
||
enum { N_EDGES = 8, TILE_STRIDE = 8, TILE_ROWS = 4,
|
||
TILE_BYTES = TILE_STRIDE * TILE_ROWS,
|
||
TOTAL = N_EDGES * TILE_BYTES, EDGE_ROW = 2,
|
||
EDGE_OFF = EDGE_ROW * TILE_STRIDE };
|
||
daedalus_ctx *ctx = daedalus_ctx_create();
|
||
if (!ctx) return 1;
|
||
|
||
uint8_t dst[TOTAL], dst_ref[TOTAL];
|
||
daedalus_h264_deblock_meta meta[N_EDGES];
|
||
|
||
for (int i = 0; i < TOTAL; i++) dst[i] = dst_ref[i] = (uint8_t)(xs() & 0xff);
|
||
for (int i = 0; i < N_EDGES; i++) {
|
||
meta[i].dst_off = i * TILE_BYTES + EDGE_OFF;
|
||
meta[i].alpha = (int)(xs() % 64) + 1;
|
||
meta[i].beta = (int)(xs() % 16) + 1;
|
||
for (int s = 0; s < 4; s++) {
|
||
int r = (int)(xs() % 8);
|
||
meta[i].tc0[s] = (int8_t)(r == 0 ? -1 : (r - 1));
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < N_EDGES; i++) {
|
||
int8_t tc0_local[4] = { meta[i].tc0[0], meta[i].tc0[1], meta[i].tc0[2], meta[i].tc0[3] };
|
||
daedalus_h264_v_loop_filter_chroma_ref(dst_ref + meta[i].dst_off, TILE_STRIDE,
|
||
meta[i].alpha, meta[i].beta, tc0_local);
|
||
}
|
||
|
||
int rc = daedalus_recipe_dispatch_h264_deblock_chroma_v(ctx, dst, TILE_STRIDE,
|
||
N_EDGES, meta);
|
||
if (rc) { fprintf(stderr, "deblock_chroma_v dispatch rc=%d\n", rc); return 1; }
|
||
int diff = 0;
|
||
for (int i = 0; i < TOTAL; i++) if (dst[i] != dst_ref[i]) diff++;
|
||
printf(" H.264 deblock chroma v: %d/%d bytes bit-exact (%.4f%%)\n",
|
||
TOTAL - diff, TOTAL, 100.0 * (TOTAL - diff) / TOTAL);
|
||
daedalus_ctx_destroy(ctx);
|
||
return diff == 0 ? 0 : 1;
|
||
}
|
||
|
||
static int test_deblock_chroma_h(void)
|
||
{
|
||
/* Chroma H: per-tile 4 cols × 8 rows, edge between cols 1 and 2
|
||
* (EDGE_COL=2 lets the kernel read pix[-2..+1] safely). */
|
||
enum { N_EDGES = 8, TILE_STRIDE = 4, TILE_ROWS = 8,
|
||
TILE_BYTES = TILE_STRIDE * TILE_ROWS,
|
||
TOTAL = N_EDGES * TILE_BYTES, EDGE_COL = 2 };
|
||
daedalus_ctx *ctx = daedalus_ctx_create();
|
||
if (!ctx) return 1;
|
||
|
||
uint8_t dst[TOTAL], dst_ref[TOTAL];
|
||
daedalus_h264_deblock_meta meta[N_EDGES];
|
||
|
||
for (int i = 0; i < TOTAL; i++) dst[i] = dst_ref[i] = (uint8_t)(xs() & 0xff);
|
||
for (int i = 0; i < N_EDGES; i++) {
|
||
meta[i].dst_off = i * TILE_BYTES + EDGE_COL;
|
||
meta[i].alpha = (int)(xs() % 64) + 1;
|
||
meta[i].beta = (int)(xs() % 16) + 1;
|
||
for (int s = 0; s < 4; s++) {
|
||
int r = (int)(xs() % 8);
|
||
meta[i].tc0[s] = (int8_t)(r == 0 ? -1 : (r - 1));
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < N_EDGES; i++) {
|
||
int8_t tc0_local[4] = { meta[i].tc0[0], meta[i].tc0[1], meta[i].tc0[2], meta[i].tc0[3] };
|
||
daedalus_h264_h_loop_filter_chroma_ref(dst_ref + meta[i].dst_off, TILE_STRIDE,
|
||
meta[i].alpha, meta[i].beta, tc0_local);
|
||
}
|
||
|
||
int rc = daedalus_recipe_dispatch_h264_deblock_chroma_h(ctx, dst, TILE_STRIDE,
|
||
N_EDGES, meta);
|
||
if (rc) { fprintf(stderr, "deblock_chroma_h dispatch rc=%d\n", rc); return 1; }
|
||
int diff = 0;
|
||
for (int i = 0; i < TOTAL; i++) if (dst[i] != dst_ref[i]) diff++;
|
||
printf(" H.264 deblock chroma h: %d/%d bytes bit-exact (%.4f%%)\n",
|
||
TOTAL - diff, TOTAL, 100.0 * (TOTAL - diff) / TOTAL);
|
||
daedalus_ctx_destroy(ctx);
|
||
return diff == 0 ? 0 : 1;
|
||
}
|
||
|
||
/* --- bS=4 intra-strength deblock tests ---
|
||
* Tile geometry per orientation matches the bS<4 variant; only the
|
||
* dispatch + reference function change. alpha/beta are non-trivial
|
||
* (the C ref + NEON both early-return when alpha|beta == 0).
|
||
*/
|
||
typedef struct {
|
||
const char *name;
|
||
int n_edges, tile_stride, tile_rows, edge_off;
|
||
void (*ref)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta);
|
||
int (*dispatch)(daedalus_ctx *ctx, uint8_t *dst, size_t dst_stride,
|
||
size_t n_edges, const daedalus_h264_deblock_meta *meta);
|
||
} intra_test_spec;
|
||
|
||
static int run_intra_test(const intra_test_spec *t)
|
||
{
|
||
int total = t->n_edges * t->tile_stride * t->tile_rows;
|
||
daedalus_ctx *ctx = daedalus_ctx_create();
|
||
if (!ctx) return 1;
|
||
|
||
uint8_t *dst = malloc((size_t) total);
|
||
uint8_t *dst_ref = malloc((size_t) total);
|
||
daedalus_h264_deblock_meta *meta = calloc((size_t) t->n_edges, sizeof(*meta));
|
||
if (!dst || !dst_ref || !meta) return 1;
|
||
|
||
for (int i = 0; i < total; i++) dst[i] = dst_ref[i] = (uint8_t)(xs() & 0xff);
|
||
int tile_bytes = t->tile_stride * t->tile_rows;
|
||
for (int i = 0; i < t->n_edges; i++) {
|
||
meta[i].dst_off = (uint32_t)(i * tile_bytes + t->edge_off);
|
||
meta[i].alpha = (int)(xs() % 64) + 1;
|
||
meta[i].beta = (int)(xs() % 16) + 1;
|
||
/* tc0[] unused for intra; leave at 0 from calloc. */
|
||
}
|
||
for (int i = 0; i < t->n_edges; i++) {
|
||
t->ref(dst_ref + meta[i].dst_off,
|
||
(ptrdiff_t) t->tile_stride,
|
||
meta[i].alpha, meta[i].beta);
|
||
}
|
||
int rc = t->dispatch(ctx, dst, (size_t) t->tile_stride,
|
||
(size_t) t->n_edges, meta);
|
||
if (rc) { fprintf(stderr, "%s dispatch rc=%d\n", t->name, rc); return 1; }
|
||
|
||
int diff = 0;
|
||
for (int i = 0; i < total; i++) if (dst[i] != dst_ref[i]) diff++;
|
||
printf(" H.264 deblock %s: %d/%d bytes bit-exact (%.4f%%)\n",
|
||
t->name, total - diff, total, 100.0 * (total - diff) / total);
|
||
|
||
free(meta); free(dst_ref); free(dst);
|
||
daedalus_ctx_destroy(ctx);
|
||
return diff == 0 ? 0 : 1;
|
||
}
|
||
|
||
static int test_deblock_intra_all(void)
|
||
{
|
||
intra_test_spec specs[] = {
|
||
{ "luma v intra", 8, 16, 8, 4 * 16,
|
||
daedalus_h264_v_loop_filter_luma_intra_ref,
|
||
daedalus_recipe_dispatch_h264_deblock_luma_v_intra },
|
||
{ "luma h intra", 8, 8, 16, 4,
|
||
daedalus_h264_h_loop_filter_luma_intra_ref,
|
||
daedalus_recipe_dispatch_h264_deblock_luma_h_intra },
|
||
{ "chroma v intra", 8, 8, 4, 2 * 8,
|
||
daedalus_h264_v_loop_filter_chroma_intra_ref,
|
||
daedalus_recipe_dispatch_h264_deblock_chroma_v_intra },
|
||
{ "chroma h intra", 8, 4, 8, 2,
|
||
daedalus_h264_h_loop_filter_chroma_intra_ref,
|
||
daedalus_recipe_dispatch_h264_deblock_chroma_h_intra },
|
||
};
|
||
int fail = 0;
|
||
for (size_t i = 0; i < sizeof(specs)/sizeof(specs[0]); i++)
|
||
fail |= run_intra_test(&specs[i]);
|
||
return fail;
|
||
}
|
||
|
||
static int test_qpel_mc20(void)
|
||
{
|
||
/* Cycle 9 — one 8x8 block per 16-wide row-tile, 8 tiles. Each tile
|
||
* holds rows 0..7; src[c-2..c+3] read via SRC_COL offset matches the
|
||
* cycle-9 bench convention so the same C reference and NEON .S can
|
||
* be compared. */
|
||
enum { N = 8, TILE_STRIDE = 16, TILE_ROWS = 8,
|
||
TILE_BYTES = TILE_ROWS * TILE_STRIDE, TOTAL = N * TILE_BYTES,
|
||
SRC_COL = 3 };
|
||
daedalus_ctx *ctx = daedalus_ctx_create();
|
||
if (!ctx) return 1;
|
||
|
||
uint8_t src[TOTAL], dst[TOTAL], dst_ref[TOTAL];
|
||
daedalus_h264_qpel_meta meta[N];
|
||
|
||
for (int i = 0; i < TOTAL; i++) src[i] = (uint8_t)(xs() & 0xff);
|
||
memset(dst, 0, sizeof(dst));
|
||
memset(dst_ref, 0, sizeof(dst_ref));
|
||
|
||
for (int i = 0; i < N; i++) {
|
||
meta[i].src_off = (uint32_t)(i * TILE_BYTES + SRC_COL);
|
||
meta[i].dst_off = (uint32_t)(i * TILE_BYTES + SRC_COL);
|
||
}
|
||
|
||
for (int i = 0; i < N; i++)
|
||
daedalus_put_h264_qpel8_mc20_ref(dst_ref + meta[i].dst_off,
|
||
src + meta[i].src_off,
|
||
TILE_STRIDE);
|
||
|
||
int rc = daedalus_recipe_dispatch_h264_qpel_mc20(ctx, dst, src,
|
||
TILE_STRIDE, N, meta);
|
||
if (rc) { fprintf(stderr, "qpel_mc20 dispatch rc=%d\n", rc); return 1; }
|
||
int diff = 0;
|
||
for (int i = 0; i < TOTAL; i++) if (dst[i] != dst_ref[i]) diff++;
|
||
printf(" H.264 qpel mc20: %d/%d bytes bit-exact (%.4f%%)\n",
|
||
TOTAL - diff, TOTAL, 100.0 * (TOTAL - diff) / TOTAL);
|
||
daedalus_ctx_destroy(ctx);
|
||
return diff == 0 ? 0 : 1;
|
||
}
|
||
|
||
int main(void)
|
||
{
|
||
printf("=== Phase 8a API smoke: H.264 kernels via recipe dispatch ===\n");
|
||
printf(" H264_IDCT4 recipe substrate: %d (1=CPU, 2=QPU)\n",
|
||
(int) daedalus_recipe_substrate_for(DAEDALUS_KERNEL_H264_IDCT4));
|
||
printf(" H264_IDCT8 recipe substrate: %d\n",
|
||
(int) daedalus_recipe_substrate_for(DAEDALUS_KERNEL_H264_IDCT8));
|
||
printf(" H264_DEBLOCK_LV recipe substrate: %d\n",
|
||
(int) daedalus_recipe_substrate_for(DAEDALUS_KERNEL_H264_DEBLOCK_LV));
|
||
printf(" H264_QPEL_MC20 recipe substrate: %d\n",
|
||
(int) daedalus_recipe_substrate_for(DAEDALUS_KERNEL_H264_QPEL_MC20));
|
||
|
||
printf(" H264_DEBLOCK_LH recipe substrate: %d (CPU, no QPU H shader yet)\n",
|
||
(int) daedalus_recipe_substrate_for(DAEDALUS_KERNEL_H264_DEBLOCK_LH));
|
||
printf(" H264_DEBLOCK_CV recipe substrate: %d (CPU)\n",
|
||
(int) daedalus_recipe_substrate_for(DAEDALUS_KERNEL_H264_DEBLOCK_CV));
|
||
printf(" H264_DEBLOCK_CH recipe substrate: %d (CPU)\n",
|
||
(int) daedalus_recipe_substrate_for(DAEDALUS_KERNEL_H264_DEBLOCK_CH));
|
||
printf(" H264_DEBLOCK_*_INTRA recipe substrate: %d (CPU, bS=4 set)\n",
|
||
(int) daedalus_recipe_substrate_for(DAEDALUS_KERNEL_H264_DEBLOCK_LV_INTRA));
|
||
|
||
int fail = 0;
|
||
fail |= test_idct4();
|
||
fail |= test_idct8();
|
||
fail |= test_deblock();
|
||
fail |= test_deblock_h();
|
||
fail |= test_deblock_chroma_v();
|
||
fail |= test_deblock_chroma_h();
|
||
fail |= test_deblock_intra_all();
|
||
fail |= test_qpel_mc20();
|
||
return fail;
|
||
}
|