diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1f10f1b..80129f5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -393,6 +393,9 @@ add_library(daedalus_core STATIC
     src/daedalus_core.c
     src/h264_chroma_dc.c
     src/h264_intra_pred_4x4.c
+    src/h264_intra_pred_16x16.c
+    src/h264_intra_pred_chroma8x8.c
+    src/h264_intra_pred_8x8_luma.c
     src/v3d_runner.c
     ${FFASM_SOURCES}
     ${FFASM_LPF_SOURCES}
@@ -547,29 +550,21 @@ add_executable(test_intra_pred_4x4 tests/test_intra_pred_4x4.c)
 target_link_libraries(test_intra_pred_4x4 PRIVATE daedalus_core)
 target_compile_options(test_intra_pred_4x4 PRIVATE -O2)
 
-# H.264 Intra_16x16 luma prediction (4 modes: V, H, DC, Plane) —
-# reference + tests.  Same spec-gate role as the 4x4 sibling.
-add_executable(test_intra_pred_16x16
-    tests/test_intra_pred_16x16.c
-    tests/h264_intra_pred_16x16_ref.c
-)
+# H.264 Intra_16x16 luma prediction (4 modes) — public src primitives,
+# linked from daedalus_core.
+add_executable(test_intra_pred_16x16 tests/test_intra_pred_16x16.c)
+target_link_libraries(test_intra_pred_16x16 PRIVATE daedalus_core)
 target_compile_options(test_intra_pred_16x16 PRIVATE -O2)
 
-# H.264 Intra_8x8 chroma prediction (4 modes: DC, H, V, Plane) —
-# reference + tests.  DC is per-quadrant (asymmetric); Plane uses
-# slope coefficient 34 instead of luma's 5.
-add_executable(test_intra_pred_chroma8x8
-    tests/test_intra_pred_chroma8x8.c
-    tests/h264_intra_pred_chroma8x8_ref.c
-)
+# H.264 Intra_8x8 chroma prediction (4 modes) — public src primitives.
+add_executable(test_intra_pred_chroma8x8 tests/test_intra_pred_chroma8x8.c)
+target_link_libraries(test_intra_pred_chroma8x8 PRIVATE daedalus_core)
 target_compile_options(test_intra_pred_chroma8x8 PRIVATE -O2)
 
 # H.264 Intra_8x8 luma prediction (High profile, 9 modes + 1-2-1
-# reference-sample pre-filter).
-add_executable(test_intra_pred_8x8_luma
-    tests/test_intra_pred_8x8_luma.c
-    tests/h264_intra_pred_8x8_luma_ref.c
-)
+# pre-filter) — public src primitives.
+add_executable(test_intra_pred_8x8_luma tests/test_intra_pred_8x8_luma.c)
+target_link_libraries(test_intra_pred_8x8_luma PRIVATE daedalus_core)
 target_compile_options(test_intra_pred_8x8_luma PRIVATE -O2)
 
 # H.264 chroma DC 2x2 Hadamard pre-pass primitive.  Pure transform,
diff --git a/include/daedalus.h b/include/daedalus.h
index cd76602..befea23 100644
--- a/include/daedalus.h
+++ b/include/daedalus.h
@@ -586,6 +586,46 @@ void daedalus_h264_pred_4x4_hd        (uint8_t *dst, ptrdiff_t stride);
 void daedalus_h264_pred_4x4_vl        (uint8_t *dst, ptrdiff_t stride);
 void daedalus_h264_pred_4x4_hu        (uint8_t *dst, ptrdiff_t stride);
 
+/* -------------------------------------------------------------------
+ * H.264 Intra_16x16 luma prediction (per §8.3.2).  4 modes:
+ * Vertical / Horizontal / DC / Plane.  Same FFmpeg-style interface
+ * as the 4x4 family at 16x16 scale.  Same neighbour availability
+ * assumption (interior-MB).
+ * ----------------------------------------------------------------- */
+void daedalus_h264_pred_16x16_vertical  (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_16x16_horizontal(uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_16x16_dc        (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_16x16_plane     (uint8_t *dst, ptrdiff_t stride);
+
+/* -------------------------------------------------------------------
+ * H.264 Intra_8x8 chroma prediction (per §8.3.3, 4:2:0).  4 modes:
+ * DC / Horizontal / Vertical / Plane.  Note: DC is per-quadrant
+ * asymmetric; Plane uses slope coefficient 34 (not luma's 5).
+ * ----------------------------------------------------------------- */
+void daedalus_h264_pred_chroma8x8_dc        (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_chroma8x8_horizontal(uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_chroma8x8_vertical  (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_chroma8x8_plane     (uint8_t *dst, ptrdiff_t stride);
+
+/* -------------------------------------------------------------------
+ * H.264 Intra_8x8 luma prediction (High profile, per §8.3.2.1).
+ * 9 modes with the spec-defined 1-2-1 reference-sample pre-filter
+ * applied internally to the 25 neighbours before the mode arithmetic.
+ *
+ * "_8x8l" naming follows the FFmpeg h264pred_template convention
+ * (pred8x8l_<mode>_c) to keep the substitution wrappers a 1:1 name
+ * map.
+ * ----------------------------------------------------------------- */
+void daedalus_h264_pred_8x8l_vertical  (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_8x8l_horizontal(uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_8x8l_dc        (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_8x8l_ddl       (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_8x8l_ddr       (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_8x8l_vr        (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_8x8l_hd        (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_8x8l_vl        (uint8_t *dst, ptrdiff_t stride);
+void daedalus_h264_pred_8x8l_hu        (uint8_t *dst, ptrdiff_t stride);
+
 /* -------------------------------------------------------------------
  * Recipe query — what does the API recommend for each kernel?
  * ----------------------------------------------------------------- */
diff --git a/tests/h264_intra_pred_16x16_ref.c b/src/h264_intra_pred_16x16.c
similarity index 92%
rename from tests/h264_intra_pred_16x16_ref.c
rename to src/h264_intra_pred_16x16.c
index 81c0ed8..eb1be0f 100644
--- a/tests/h264_intra_pred_16x16_ref.c
+++ b/src/h264_intra_pred_16x16.c
@@ -29,7 +29,7 @@
 static inline int clip_u8(int v) { return v < 0 ? 0 : v > 255 ? 255 : v; }
 
 /* Mode 0 — Vertical: each col = top[col]. */
-void daedalus_h264_pred_16x16_vertical_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_16x16_vertical(uint8_t *dst, ptrdiff_t stride)
 {
     const uint8_t *top = dst - stride;
     for (int r = 0; r < 16; r++)
@@ -37,7 +37,7 @@ void daedalus_h264_pred_16x16_vertical_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 1 — Horizontal: each row = left[row]. */
-void daedalus_h264_pred_16x16_horizontal_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_16x16_horizontal(uint8_t *dst, ptrdiff_t stride)
 {
     for (int r = 0; r < 16; r++) {
         uint8_t l = dst[r * stride - 1];
@@ -46,7 +46,7 @@ void daedalus_h264_pred_16x16_horizontal_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 2 — DC: ((sum_top16 + sum_left16 + 16) >> 5) broadcast. */
-void daedalus_h264_pred_16x16_dc_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_16x16_dc(uint8_t *dst, ptrdiff_t stride)
 {
     const uint8_t *top = dst - stride;
     int sum = 16;  /* rounding for >> 5 over 32 samples */
@@ -77,7 +77,7 @@ void daedalus_h264_pred_16x16_dc_ref(uint8_t *dst, ptrdiff_t stride)
  * (it does NOT participate in the H/V sums in the 16x16 case — only
  * for the chroma 8x8 plane mode).
  */
-void daedalus_h264_pred_16x16_plane_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_16x16_plane(uint8_t *dst, ptrdiff_t stride)
 {
     const uint8_t *top = dst - stride;
     /* H accumulates differences across the right vs left half of the
diff --git a/tests/h264_intra_pred_8x8_luma_ref.c b/src/h264_intra_pred_8x8_luma.c
similarity index 95%
rename from tests/h264_intra_pred_8x8_luma_ref.c
rename to src/h264_intra_pred_8x8_luma.c
index 14d7b06..1e6c5bb 100644
--- a/tests/h264_intra_pred_8x8_luma_ref.c
+++ b/src/h264_intra_pred_8x8_luma.c
@@ -90,7 +90,7 @@ static void filter_refs(const uint8_t *dst, ptrdiff_t stride,
 #define FTL    filt[0]          /* filtered top-left              */
 
 /* Mode 0 Vertical (§8.3.2.1.2): pred[r,c] = filt_top[c]. */
-void daedalus_h264_pred_8x8l_vertical_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_vertical(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
@@ -99,7 +99,7 @@ void daedalus_h264_pred_8x8l_vertical_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 1 Horizontal (§8.3.2.1.3): pred[r,c] = filt_left[r]. */
-void daedalus_h264_pred_8x8l_horizontal_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_horizontal(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
@@ -110,7 +110,7 @@ void daedalus_h264_pred_8x8l_horizontal_ref(uint8_t *dst, ptrdiff_t stride)
 /* Mode 2 DC (§8.3.2.1.4): ((sum_filt_top[0..7] + sum_filt_left[0..7]
  * + 8) >> 4) broadcast.  Note the +8 (not +4 like 4x4): there are
  * 16 samples summed total, so >> 4 with half-step rounding +8. */
-void daedalus_h264_pred_8x8l_dc_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_dc(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
@@ -143,7 +143,7 @@ void daedalus_h264_pred_8x8l_dc_ref(uint8_t *dst, ptrdiff_t stride)
 #define LT    FTL
 
 /* Mode 3 DDL (Diagonal_Down_Left) — uses TOP + TOP_RIGHT, no LEFT. */
-void daedalus_h264_pred_8x8l_ddl_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_ddl(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
@@ -165,7 +165,7 @@ void daedalus_h264_pred_8x8l_ddl_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 4 DDR (Diagonal_Down_Right). */
-void daedalus_h264_pred_8x8l_ddr_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_ddr(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
@@ -187,7 +187,7 @@ void daedalus_h264_pred_8x8l_ddr_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 5 VR (Vertical_Right). */
-void daedalus_h264_pred_8x8l_vr_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_vr(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
@@ -216,7 +216,7 @@ void daedalus_h264_pred_8x8l_vr_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 6 HD (Horizontal_Down). */
-void daedalus_h264_pred_8x8l_hd_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_hd(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
@@ -245,7 +245,7 @@ void daedalus_h264_pred_8x8l_hd_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 7 VL (Vertical_Left) — uses TOP + TOP_RIGHT only. */
-void daedalus_h264_pred_8x8l_vl_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_vl(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
@@ -274,7 +274,7 @@ void daedalus_h264_pred_8x8l_vl_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 8 HU (Horizontal_Up) — uses LEFT only. */
-void daedalus_h264_pred_8x8l_hu_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_8x8l_hu(uint8_t *dst, ptrdiff_t stride)
 {
     uint8_t filt[25];
     filter_refs(dst, stride, filt);
diff --git a/tests/h264_intra_pred_chroma8x8_ref.c b/src/h264_intra_pred_chroma8x8.c
similarity index 93%
rename from tests/h264_intra_pred_chroma8x8_ref.c
rename to src/h264_intra_pred_chroma8x8.c
index da82024..8621cd3 100644
--- a/tests/h264_intra_pred_chroma8x8_ref.c
+++ b/src/h264_intra_pred_chroma8x8.c
@@ -43,7 +43,7 @@ static inline int clip_u8(int v) { return v < 0 ? 0 : v > 255 ? 255 : v; }
  * quadrant ignores the top-left-half because that half is "vertically
  * above" the top-left quadrant; the spec uses top[4..7] only.
  */
-void daedalus_h264_pred_chroma8x8_dc_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_chroma8x8_dc(uint8_t *dst, ptrdiff_t stride)
 {
     const uint8_t *top = dst - stride;
     int top_lo = 0, top_hi = 0, left_lo = 0, left_hi = 0;
@@ -68,7 +68,7 @@ void daedalus_h264_pred_chroma8x8_dc_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 1 — Horizontal: each row = left[row]. */
-void daedalus_h264_pred_chroma8x8_horizontal_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_chroma8x8_horizontal(uint8_t *dst, ptrdiff_t stride)
 {
     for (int r = 0; r < 8; r++) {
         uint8_t l = dst[r * stride - 1];
@@ -77,7 +77,7 @@ void daedalus_h264_pred_chroma8x8_horizontal_ref(uint8_t *dst, ptrdiff_t stride)
 }
 
 /* Mode 2 — Vertical: each col = top[col]. */
-void daedalus_h264_pred_chroma8x8_vertical_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_chroma8x8_vertical(uint8_t *dst, ptrdiff_t stride)
 {
     const uint8_t *top = dst - stride;
     for (int r = 0; r < 8; r++)
@@ -97,7 +97,7 @@ void daedalus_h264_pred_chroma8x8_vertical_ref(uint8_t *dst, ptrdiff_t stride)
  *   - Centre is (x-3, y-3) (not x-7, y-7).
  *   - Spans 4 differences per sum (not 8).
  */
-void daedalus_h264_pred_chroma8x8_plane_ref(uint8_t *dst, ptrdiff_t stride)
+void daedalus_h264_pred_chroma8x8_plane(uint8_t *dst, ptrdiff_t stride)
 {
     const uint8_t *top = dst - stride;
     int H = 0, V = 0;
diff --git a/tests/test_intra_pred_16x16.c b/tests/test_intra_pred_16x16.c
index 24aa45d..64898c4 100644
--- a/tests/test_intra_pred_16x16.c
+++ b/tests/test_intra_pred_16x16.c
@@ -18,10 +18,10 @@
 #include <stdio.h>
 #include <string.h>
 
-extern void daedalus_h264_pred_16x16_vertical_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_16x16_horizontal_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_16x16_dc_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_16x16_plane_ref(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_16x16_vertical(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_16x16_horizontal(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_16x16_dc(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_16x16_plane(uint8_t *dst, ptrdiff_t stride);
 
 #define STRIDE 17
 #define ROWS   17
@@ -84,7 +84,7 @@ int main(void)
         int t[16], l[16];
         for (int i = 0; i < 16; i++) { t[i] = 10 + i; l[i] = 0; }
         set_ctx(buf, 0, t, l);
-        daedalus_h264_pred_16x16_vertical_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_16x16_vertical(&buf[1][1], STRIDE);
         struct vertical_ctx vc = { t };
         fail |= check(buf, "Vertical (mode 0)", expect_vertical, &vc);
     }
@@ -95,7 +95,7 @@ int main(void)
         int t[16] = {0}, l[16];
         for (int i = 0; i < 16; i++) l[i] = 50 + i;
         set_ctx(buf, 0, t, l);
-        daedalus_h264_pred_16x16_horizontal_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_16x16_horizontal(&buf[1][1], STRIDE);
         struct horizontal_ctx hc = { l };
         fail |= check(buf, "Horizontal (mode 1)", expect_horizontal, &hc);
     }
@@ -108,7 +108,7 @@ int main(void)
         int t[16], l[16];
         for (int i = 0; i < 16; i++) { t[i] = 2; l[i] = 6; }
         set_ctx(buf, 99, t, l);
-        daedalus_h264_pred_16x16_dc_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_16x16_dc(&buf[1][1], STRIDE);
         uint8_t exp_val = 4;
         fail |= check(buf, "DC (mode 2)", expect_uniform, &exp_val);
     }
@@ -123,7 +123,7 @@ int main(void)
         int t[16], l[16];
         for (int i = 0; i < 16; i++) { t[i] = 100; l[i] = 100; }
         set_ctx(buf, 100, t, l);   /* uniform tl too — H/V sums actually zero */
-        daedalus_h264_pred_16x16_plane_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_16x16_plane(&buf[1][1], STRIDE);
         uint8_t exp_val = 100;
         fail |= check(buf, "Plane (mode 3, uniform)", expect_uniform, &exp_val);
     }
@@ -150,7 +150,7 @@ int main(void)
         int t[16], l[16];
         for (int i = 0; i < 16; i++) { t[i] = i; l[i] = i; }
         set_ctx(buf, 0, t, l);
-        daedalus_h264_pred_16x16_plane_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_16x16_plane(&buf[1][1], STRIDE);
         uint8_t tl_actual = buf[1 + 0][1 + 0];
         uint8_t br_actual = buf[1 + 15][1 + 15];
         int spot_fail = 0;
diff --git a/tests/test_intra_pred_8x8_luma.c b/tests/test_intra_pred_8x8_luma.c
index 5beffda..dc62953 100644
--- a/tests/test_intra_pred_8x8_luma.c
+++ b/tests/test_intra_pred_8x8_luma.c
@@ -14,15 +14,15 @@
 #include <stdio.h>
 #include <string.h>
 
-extern void daedalus_h264_pred_8x8l_vertical_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_8x8l_horizontal_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_8x8l_dc_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_8x8l_ddl_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_8x8l_ddr_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_8x8l_vr_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_8x8l_hd_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_8x8l_vl_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_8x8l_hu_ref(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_vertical(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_horizontal(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_dc(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_ddl(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_ddr(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_vr(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_hd(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_vl(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_8x8l_hu(uint8_t *dst, ptrdiff_t stride);
 
 #define STRIDE 17
 #define ROWS   9
@@ -61,7 +61,7 @@ int main(void)
         for (int i = 0; i < 16; i++) t[i] = 50;
         for (int j = 0; j < 8; j++)  l[j] = 0;
         set_ctx(buf, 50, t, l);
-        daedalus_h264_pred_8x8l_vertical_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_8x8l_vertical(&buf[1][1], STRIDE);
         fail |= check_uniform(buf, "Vertical (mode 0, uniform top)", 50);
     }
 
@@ -71,7 +71,7 @@ int main(void)
         int t[16] = {0}, l[8];
         for (int j = 0; j < 8; j++) l[j] = 70;
         set_ctx(buf, 70, t, l);
-        daedalus_h264_pred_8x8l_horizontal_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_8x8l_horizontal(&buf[1][1], STRIDE);
         fail |= check_uniform(buf, "Horizontal (mode 1, uniform left)", 70);
     }
 
@@ -84,7 +84,7 @@ int main(void)
         for (int i = 0; i < 16; i++) t[i] = 33;
         for (int j = 0; j < 8; j++)  l[j] = 33;
         set_ctx(buf, 33, t, l);
-        daedalus_h264_pred_8x8l_dc_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_8x8l_dc(&buf[1][1], STRIDE);
         fail |= check_uniform(buf, "DC (mode 2, uniform)", 33);
     }
 
@@ -108,7 +108,7 @@ int main(void)
         int t[16], l[8] = {0};
         for (int i = 0; i < 16; i++) t[i] = i;
         set_ctx(buf, 0, t, l);
-        daedalus_h264_pred_8x8l_vertical_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_8x8l_vertical(&buf[1][1], STRIDE);
         int diff = 0;
         for (int r = 0; r < 8; r++)
             for (int c = 0; c < 8; c++)
@@ -129,7 +129,7 @@ int main(void)
         int t[16] = {0}, l[8];
         for (int j = 0; j < 8; j++) l[j] = j;
         set_ctx(buf, 0, t, l);
-        daedalus_h264_pred_8x8l_horizontal_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_8x8l_horizontal(&buf[1][1], STRIDE);
         int diff = 0;
         for (int r = 0; r < 8; r++)
             for (int c = 0; c < 8; c++)
@@ -146,12 +146,12 @@ int main(void)
     {
         typedef void (*pred_fn_t)(uint8_t *dst, ptrdiff_t stride);
         struct { const char *name; pred_fn_t fn; } modes[] = {
-            { "DDL (mode 3, uniform)",        daedalus_h264_pred_8x8l_ddl_ref },
-            { "DDR (mode 4, uniform)",        daedalus_h264_pred_8x8l_ddr_ref },
-            { "VR (mode 5, uniform)",         daedalus_h264_pred_8x8l_vr_ref  },
-            { "HD (mode 6, uniform)",         daedalus_h264_pred_8x8l_hd_ref  },
-            { "VL (mode 7, uniform)",         daedalus_h264_pred_8x8l_vl_ref  },
-            { "HU (mode 8, uniform)",         daedalus_h264_pred_8x8l_hu_ref  },
+            { "DDL (mode 3, uniform)",        daedalus_h264_pred_8x8l_ddl },
+            { "DDR (mode 4, uniform)",        daedalus_h264_pred_8x8l_ddr },
+            { "VR (mode 5, uniform)",         daedalus_h264_pred_8x8l_vr  },
+            { "HD (mode 6, uniform)",         daedalus_h264_pred_8x8l_hd  },
+            { "VL (mode 7, uniform)",         daedalus_h264_pred_8x8l_vl  },
+            { "HU (mode 8, uniform)",         daedalus_h264_pred_8x8l_hu  },
         };
         for (size_t i = 0; i < sizeof(modes)/sizeof(modes[0]); i++) {
             uint8_t buf[ROWS][STRIDE];
diff --git a/tests/test_intra_pred_chroma8x8.c b/tests/test_intra_pred_chroma8x8.c
index acb9d08..76c0442 100644
--- a/tests/test_intra_pred_chroma8x8.c
+++ b/tests/test_intra_pred_chroma8x8.c
@@ -16,10 +16,10 @@
 #include <stdio.h>
 #include <string.h>
 
-extern void daedalus_h264_pred_chroma8x8_dc_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_chroma8x8_horizontal_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_chroma8x8_vertical_ref(uint8_t *dst, ptrdiff_t stride);
-extern void daedalus_h264_pred_chroma8x8_plane_ref(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_chroma8x8_dc(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_chroma8x8_horizontal(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_chroma8x8_vertical(uint8_t *dst, ptrdiff_t stride);
+extern void daedalus_h264_pred_chroma8x8_plane(uint8_t *dst, ptrdiff_t stride);
 
 #define STRIDE 9
 #define ROWS   9
@@ -69,7 +69,7 @@ int main(void)
         uint8_t buf[ROWS][STRIDE];
         int t[8] = {0}, l[8] = {10, 20, 30, 40, 50, 60, 70, 80};
         set_ctx(buf, 0, t, l);
-        daedalus_h264_pred_chroma8x8_horizontal_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_chroma8x8_horizontal(&buf[1][1], STRIDE);
         uint8_t exp[8][8];
         for (int r = 0; r < 8; r++) for (int c = 0; c < 8; c++) exp[r][c] = (uint8_t) l[r];
         fail |= check_per_cell(buf, "Horizontal (mode 1)", exp);
@@ -80,7 +80,7 @@ int main(void)
         uint8_t buf[ROWS][STRIDE];
         int t[8] = {15, 25, 35, 45, 55, 65, 75, 85}, l[8] = {0};
         set_ctx(buf, 0, t, l);
-        daedalus_h264_pred_chroma8x8_vertical_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_chroma8x8_vertical(&buf[1][1], STRIDE);
         uint8_t exp[8][8];
         for (int r = 0; r < 8; r++) for (int c = 0; c < 8; c++) exp[r][c] = (uint8_t) t[c];
         fail |= check_per_cell(buf, "Vertical (mode 2)", exp);
@@ -104,7 +104,7 @@ int main(void)
         int t[8] = { 8, 8, 8, 8,  16, 16, 16, 16 };
         int l[8] = { 24, 24, 24, 24,  40, 40, 40, 40 };
         set_ctx(buf, 99, t, l);
-        daedalus_h264_pred_chroma8x8_dc_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_chroma8x8_dc(&buf[1][1], STRIDE);
         uint8_t exp[8][8] = {
             {16,16,16,16, 16,16,16,16},
             {16,16,16,16, 16,16,16,16},
@@ -125,7 +125,7 @@ int main(void)
         int t[8], l[8];
         for (int i = 0; i < 8; i++) { t[i] = 100; l[i] = 100; }
         set_ctx(buf, 100, t, l);
-        daedalus_h264_pred_chroma8x8_plane_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_chroma8x8_plane(&buf[1][1], STRIDE);
         uint8_t exp[8][8];
         for (int r = 0; r < 8; r++) for (int c = 0; c < 8; c++) exp[r][c] = 100;
         fail |= check_per_cell(buf, "Plane uniform (mode 3)", exp);
@@ -153,7 +153,7 @@ int main(void)
         int t[8], l[8];
         for (int i = 0; i < 8; i++) { t[i] = i; l[i] = i; }
         set_ctx(buf, 0, t, l);
-        daedalus_h264_pred_chroma8x8_plane_ref(&buf[1][1], STRIDE);
+        daedalus_h264_pred_chroma8x8_plane(&buf[1][1], STRIDE);
         uint8_t tl_actual = buf[1 + 0][1 + 0];
         uint8_t br_actual = buf[1 + 7][1 + 7];
         int spot_fail = 0;