diff --git a/apps/shared/y4m.c b/apps/shared/y4m.c
index e924600..e6519f6 100644
--- a/apps/shared/y4m.c
+++ b/apps/shared/y4m.c
@@ -457,7 +457,8 @@
                     y4mHeaderFormat = "Cmono XYSCSS=400";
                     break;
                 case AVIF_PIXEL_FORMAT_NONE:
-                    // will error later; this case is here for warning's sake
+                case AVIF_PIXEL_FORMAT_COUNT:
+                    // will error later; these cases are here for warning's sake
                     break;
             }
             break;
@@ -476,7 +477,8 @@
                     y4mHeaderFormat = "Cmono10 XYSCSS=400";
                     break;
                 case AVIF_PIXEL_FORMAT_NONE:
-                    // will error later; this case is here for warning's sake
+                case AVIF_PIXEL_FORMAT_COUNT:
+                    // will error later; these cases are here for warning's sake
                     break;
             }
             break;
@@ -495,7 +497,8 @@
                     y4mHeaderFormat = "Cmono12 XYSCSS=400";
                     break;
                 case AVIF_PIXEL_FORMAT_NONE:
-                    // will error later; this case is here for warning's sake
+                case AVIF_PIXEL_FORMAT_COUNT:
+                    // will error later; these cases are here for warning's sake
                     break;
             }
             break;
diff --git a/include/avif/avif.h b/include/avif/avif.h
index 089a7e2..089c6fa 100644
--- a/include/avif/avif.h
+++ b/include/avif/avif.h
@@ -180,7 +180,11 @@
 
 // ---------------------------------------------------------------------------
 // avifPixelFormat
-
+//
+// Note to libavif maintainers: The lookup tables in avifImageYUVToRGBLibYUV
+// rely on the ordering of this enum values for their correctness. So changing
+// the values in this enum will require auditing avifImageYUVToRGBLibYUV for
+// correctness.
 typedef enum avifPixelFormat
 {
     // No YUV pixels are present. Alpha plane can still be present.
@@ -189,7 +193,8 @@
     AVIF_PIXEL_FORMAT_YUV444,
     AVIF_PIXEL_FORMAT_YUV422,
     AVIF_PIXEL_FORMAT_YUV420,
-    AVIF_PIXEL_FORMAT_YUV400
+    AVIF_PIXEL_FORMAT_YUV400,
+    AVIF_PIXEL_FORMAT_COUNT
 } avifPixelFormat;
 AVIF_API const char * avifPixelFormatToString(avifPixelFormat format);
 
@@ -544,6 +549,10 @@
 //   *  BGR             to  YUV420        /[5|6]/[Full|Limited]
 //   * [RGBA|ARGB|ABGR] to  YUV420        /[5|6]/ Limited
 
+// Note to libavif maintainers: The lookup tables in avifImageYUVToRGBLibYUV
+// rely on the ordering of this enum values for their correctness. So changing
+// the values in this enum will require auditing avifImageYUVToRGBLibYUV for
+// correctness.
 typedef enum avifRGBFormat
 {
     AVIF_RGB_FORMAT_RGB = 0,
@@ -561,7 +570,8 @@
     //   b4 and b0 are the MSB and LSB of the blue component respectively.
     // This format is only supported for YUV -> RGB conversion and when
     // avifRGBImage.depth is set to 8.
-    AVIF_RGB_FORMAT_RGB_565
+    AVIF_RGB_FORMAT_RGB_565,
+    AVIF_RGB_FORMAT_COUNT
 } avifRGBFormat;
 AVIF_API uint32_t avifRGBFormatChannelCount(avifRGBFormat format);
 AVIF_API avifBool avifRGBFormatHasAlpha(avifRGBFormat format);
diff --git a/src/avif.c b/src/avif.c
index 99b1acb..6ced063 100644
--- a/src/avif.c
+++ b/src/avif.c
@@ -28,6 +28,7 @@
         case AVIF_PIXEL_FORMAT_YUV400:
             return "YUV400";
         case AVIF_PIXEL_FORMAT_NONE:
+        case AVIF_PIXEL_FORMAT_COUNT:
         default:
             break;
     }
@@ -61,6 +62,7 @@
             break;
 
         case AVIF_PIXEL_FORMAT_NONE:
+        case AVIF_PIXEL_FORMAT_COUNT:
         default:
             break;
     }
diff --git a/src/codec_aom.c b/src/codec_aom.c
index 44deab9..a3fba99 100644
--- a/src/codec_aom.c
+++ b/src/codec_aom.c
@@ -272,6 +272,7 @@
                 fmt = AOM_IMG_FMT_I420;
                 break;
             case AVIF_PIXEL_FORMAT_NONE:
+            case AVIF_PIXEL_FORMAT_COUNT:
             default:
                 return AOM_IMG_FMT_NONE;
         }
@@ -649,6 +650,7 @@
                         seqProfile = 0;
                         break;
                     case AVIF_PIXEL_FORMAT_NONE:
+                    case AVIF_PIXEL_FORMAT_COUNT:
                     default:
                         break;
                 }
diff --git a/src/reformat.c b/src/reformat.c
index 88faf2a..1489c38 100644
--- a/src/reformat.c
+++ b/src/reformat.c
@@ -28,6 +28,10 @@
     if (rgb->format == AVIF_RGB_FORMAT_RGB_565 && rgb->depth != 8) {
         return AVIF_FALSE;
     }
+    if (image->yuvFormat <= AVIF_PIXEL_FORMAT_NONE || image->yuvFormat >= AVIF_PIXEL_FORMAT_COUNT ||
+        rgb->format < AVIF_RGB_FORMAT_RGB || rgb->format >= AVIF_RGB_FORMAT_COUNT) {
+        return AVIF_FALSE;
+    }
 
     // These matrix coefficients values are currently unsupported. Revise this list as more support is added.
     //
@@ -46,10 +50,6 @@
         return AVIF_FALSE;
     }
 
-    if (image->yuvFormat == AVIF_PIXEL_FORMAT_NONE) {
-        return AVIF_FALSE;
-    }
-
     avifGetPixelFormatInfo(image->yuvFormat, &state->formatInfo);
     avifCalcYUVCoefficients(image, &state->kr, &state->kg, &state->kb);
     state->mode = AVIF_REFORMAT_MODE_YUV_COEFFICIENTS;
@@ -119,7 +119,7 @@
             state->rgbOffsetBytesA = 0;
             break;
 
-        default:
+        case AVIF_RGB_FORMAT_COUNT:
             return AVIF_FALSE;
     }
 
diff --git a/src/reformat_libyuv.c b/src/reformat_libyuv.c
index 37d8f12..8c0b895 100644
--- a/src/reformat_libyuv.c
+++ b/src/reformat_libyuv.c
@@ -341,6 +341,37 @@
     return AVIF_RESULT_NOT_IMPLEMENTED;
 }
 
+// These defines are used to create a NULL reference to libyuv functions that
+// did not exist prior to a particular version of libyuv.
+#if LIBYUV_VERSION < 1838
+#define I422ToRGB565Matrix NULL
+#endif
+#if LIBYUV_VERSION < 1813
+#define I422ToARGBMatrixFilter NULL
+#define I420ToARGBMatrixFilter NULL
+#define I210ToARGBMatrixFilter NULL
+#define I010ToARGBMatrixFilter NULL
+#endif
+#if LIBYUV_VERSION < 1780
+#define I410ToARGBMatrix NULL
+#endif
+#if LIBYUV_VERSION < 1756
+#define I400ToARGBMatrix NULL
+#endif
+
+// Lookup table for isYVU. If the entry in this table is AVIF_TRUE, then it
+// means that we are using a libyuv function with R and B channels swapped,
+// which requires U and V planes also be swapped.
+static const avifBool lutIsYVU[AVIF_RGB_FORMAT_COUNT] = {
+    AVIF_TRUE,  // RGB
+    AVIF_TRUE,  // RGBA
+    AVIF_TRUE,  // ARGB
+    AVIF_FALSE, // BGR
+    AVIF_FALSE, // BGRA
+    AVIF_FALSE, // ABGR
+    AVIF_FALSE, // RGB_565
+};
+
 avifResult avifImageYUVToRGBLibYUV8bpc(const avifImage * image,
                                        avifRGBImage * rgb,
                                        const struct YuvConstants * matrixYUV,
@@ -350,428 +381,122 @@
 
     assert((image->depth == 8) && (rgb->depth == 8));
 
-#if LIBYUV_VERSION >= 1813
-    enum FilterMode filter = kFilterBilinear;
-    if (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_FASTEST) {
-        // 'None' (Nearest neighbor) filter is faster than bilinear.
-        filter = kFilterNone;
-    }
-#endif
-
-    // This following section might be a bit complicated to audit without a bit of explanation:
-    //
     // libavif uses byte-order when describing pixel formats, such that the R in RGBA is the lowest address,
     // similar to PNG. libyuv orders in word-order, so libavif's RGBA would be referred to in libyuv as ABGR.
     // In addition, swapping U and V in any of these calls, along with using the Yvu matrix instead of Yuv matrix,
-    // swaps B and R in these orderings as well. This table summarizes this block's intent:
+    // swaps B and R in these orderings as well. This table summarizes the lookup tables that follow:
     //
     // libavif format            libyuv Func      UV matrix (and UV argument ordering)
     // --------------------      -------------    ------------------------------------
     // AVIF_RGB_FORMAT_RGB       *ToRGB24Matrix   matrixYVU
-    // AVIF_RGB_FORMAT_BGR       *ToRGB24Matrix   matrixYUV
-    // AVIF_RGB_FORMAT_RGB_565   *ToRGB565Matrix  matrixYUV
-    // AVIF_RGB_FORMAT_BGRA      *ToARGBMatrix    matrixYUV
     // AVIF_RGB_FORMAT_RGBA      *ToARGBMatrix    matrixYVU
-    // AVIF_RGB_FORMAT_ABGR      *ToRGBAMatrix    matrixYUV
     // AVIF_RGB_FORMAT_ARGB      *ToRGBAMatrix    matrixYVU
+    // AVIF_RGB_FORMAT_BGR       *ToRGB24Matrix   matrixYUV
+    // AVIF_RGB_FORMAT_BGRA      *ToARGBMatrix    matrixYUV
+    // AVIF_RGB_FORMAT_ABGR      *ToRGBAMatrix    matrixYUV
+    // AVIF_RGB_FORMAT_RGB_565   *ToRGB565Matrix  matrixYUV
 
-    if (rgb->format == AVIF_RGB_FORMAT_RGB) {
-        // AVIF_RGB_FORMAT_RGB   *ToRGB24Matrix  matrixYVU
-
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-            if (I420ToRGB24Matrix(image->yuvPlanes[AVIF_CHAN_Y],
+    avifBool isYVU = lutIsYVU[rgb->format];
+    const struct YuvConstants * matrix = isYVU ? matrixYVU : matrixYUV;
+    if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
+        // Lookup table for YUV400 to RGB Matrix.
+        typedef int (*YUV400ToRGBMatrix)(const uint8_t *, int, uint8_t *, int, const struct YuvConstants *, int, int);
+        YUV400ToRGBMatrix lutYuv400ToRgbMatrix[AVIF_RGB_FORMAT_COUNT] = {
+            NULL,             // RGB
+            I400ToARGBMatrix, // RGBA
+            NULL,             // ARGB
+            NULL,             // BGR
+            I400ToARGBMatrix, // BGRA
+            NULL,             // ABGR
+            NULL,             // RGB_565
+        };
+        YUV400ToRGBMatrix yuv400ToRgbMatrix = lutYuv400ToRgbMatrix[rgb->format];
+        if (yuv400ToRgbMatrix != NULL) {
+            if (yuv400ToRgbMatrix(image->yuvPlanes[AVIF_CHAN_Y],
                                   image->yuvRowBytes[AVIF_CHAN_Y],
-                                  image->yuvPlanes[AVIF_CHAN_V],
-                                  image->yuvRowBytes[AVIF_CHAN_V],
-                                  image->yuvPlanes[AVIF_CHAN_U],
-                                  image->yuvRowBytes[AVIF_CHAN_U],
                                   rgb->pixels,
                                   rgb->rowBytes,
-                                  matrixYVU,
+                                  matrix,
                                   image->width,
                                   image->height) != 0) {
                 return AVIF_RESULT_REFORMAT_FAILED;
             }
             return AVIF_RESULT_OK;
         }
-    } else if (rgb->format == AVIF_RGB_FORMAT_BGR) {
-        // AVIF_RGB_FORMAT_BGR   *ToRGB24Matrix  matrixYUV
-
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-            if (I420ToRGB24Matrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                  image->yuvRowBytes[AVIF_CHAN_Y],
-                                  image->yuvPlanes[AVIF_CHAN_U],
-                                  image->yuvRowBytes[AVIF_CHAN_U],
-                                  image->yuvPlanes[AVIF_CHAN_V],
-                                  image->yuvRowBytes[AVIF_CHAN_V],
-                                  rgb->pixels,
-                                  rgb->rowBytes,
-                                  matrixYUV,
-                                  image->width,
-                                  image->height) != 0) {
+    } else {
+        int uPlaneIndex = isYVU ? AVIF_CHAN_V : AVIF_CHAN_U;
+        int vPlaneIndex = isYVU ? AVIF_CHAN_U : AVIF_CHAN_V;
+        // Lookup table for YUV To RGB Matrix (with filter).
+        typedef int (*YUVToRGBMatrixFilter)(const uint8_t *,
+                                            int,
+                                            const uint8_t *,
+                                            int,
+                                            const uint8_t *,
+                                            int,
+                                            uint8_t *,
+                                            int,
+                                            const struct YuvConstants *,
+                                            int,
+                                            int,
+                                            enum FilterMode);
+        YUVToRGBMatrixFilter lutYuvToRgbMatrixFilter[AVIF_RGB_FORMAT_COUNT][AVIF_PIXEL_FORMAT_COUNT] = {
+            { NULL, NULL, NULL, NULL, NULL },                                     // RGB
+            { NULL, NULL, I422ToARGBMatrixFilter, I420ToARGBMatrixFilter, NULL }, // RGBA
+            { NULL, NULL, NULL, NULL, NULL },                                     // ARGB
+            { NULL, NULL, NULL, NULL, NULL },                                     // BGR
+            { NULL, NULL, I422ToARGBMatrixFilter, I420ToARGBMatrixFilter, NULL }, // BGRA
+            { NULL, NULL, NULL, NULL, NULL },                                     // ABGR
+            { NULL, NULL, NULL, NULL, NULL },                                     // RGB_565
+        };
+        YUVToRGBMatrixFilter yuvToRgbMatrixFilter = lutYuvToRgbMatrixFilter[rgb->format][image->yuvFormat];
+        if (yuvToRgbMatrixFilter != NULL) {
+            // 'None' (Nearest neighbor) filter is faster than bilinear.
+            enum FilterMode filter = (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_FASTEST) ? kFilterNone : kFilterBilinear;
+            if (yuvToRgbMatrixFilter(image->yuvPlanes[AVIF_CHAN_Y],
+                                     image->yuvRowBytes[AVIF_CHAN_Y],
+                                     image->yuvPlanes[uPlaneIndex],
+                                     image->yuvRowBytes[uPlaneIndex],
+                                     image->yuvPlanes[vPlaneIndex],
+                                     image->yuvRowBytes[vPlaneIndex],
+                                     rgb->pixels,
+                                     rgb->rowBytes,
+                                     matrix,
+                                     image->width,
+                                     image->height,
+                                     filter) != 0) {
                 return AVIF_RESULT_REFORMAT_FAILED;
             }
             return AVIF_RESULT_OK;
         }
-    } else if (rgb->format == AVIF_RGB_FORMAT_RGB_565) {
-        // AVIF_RGB_FORMAT_BGR   *ToRGB565Matrix  matrixYUV
 
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422) {
-#if LIBYUV_VERSION >= 1838
-            if (I422ToRGB565Matrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                   image->yuvRowBytes[AVIF_CHAN_Y],
-                                   image->yuvPlanes[AVIF_CHAN_U],
-                                   image->yuvRowBytes[AVIF_CHAN_U],
-                                   image->yuvPlanes[AVIF_CHAN_V],
-                                   image->yuvRowBytes[AVIF_CHAN_V],
-                                   rgb->pixels,
-                                   rgb->rowBytes,
-                                   matrixYUV,
-                                   image->width,
-                                   image->height) != 0) {
+        // Lookup table for YUV To RGB Matrix (without filter).
+        typedef int (
+            *YUVToRGBMatrix)(const uint8_t *, int, const uint8_t *, int, const uint8_t *, int, uint8_t *, int, const struct YuvConstants *, int, int);
+        YUVToRGBMatrix lutYuvToRgbMatrix[AVIF_RGB_FORMAT_COUNT][AVIF_PIXEL_FORMAT_COUNT] = {
+            { NULL, NULL, NULL, I420ToRGB24Matrix, NULL },                        // RGB
+            { NULL, I444ToARGBMatrix, I422ToARGBMatrix, I420ToARGBMatrix, NULL }, // RGBA
+            { NULL, NULL, I422ToRGBAMatrix, I420ToRGBAMatrix, NULL },             // ARGB
+            { NULL, NULL, NULL, I420ToRGB24Matrix, NULL },                        // BGR
+            { NULL, I444ToARGBMatrix, I422ToARGBMatrix, I420ToARGBMatrix, NULL }, // BGRA
+            { NULL, NULL, I422ToRGBAMatrix, I420ToRGBAMatrix, NULL },             // ABGR
+            { NULL, NULL, I422ToRGB565Matrix, I420ToRGB565Matrix, NULL },         // RGB_565
+        };
+        YUVToRGBMatrix yuvToRgbMatrix = lutYuvToRgbMatrix[rgb->format][image->yuvFormat];
+        if (yuvToRgbMatrix != NULL) {
+            if (yuvToRgbMatrix(image->yuvPlanes[AVIF_CHAN_Y],
+                               image->yuvRowBytes[AVIF_CHAN_Y],
+                               image->yuvPlanes[uPlaneIndex],
+                               image->yuvRowBytes[uPlaneIndex],
+                               image->yuvPlanes[vPlaneIndex],
+                               image->yuvRowBytes[vPlaneIndex],
+                               rgb->pixels,
+                               rgb->rowBytes,
+                               matrix,
+                               image->width,
+                               image->height) != 0) {
                 return AVIF_RESULT_REFORMAT_FAILED;
             }
             return AVIF_RESULT_OK;
-#endif
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-            if (I420ToRGB565Matrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                   image->yuvRowBytes[AVIF_CHAN_Y],
-                                   image->yuvPlanes[AVIF_CHAN_U],
-                                   image->yuvRowBytes[AVIF_CHAN_U],
-                                   image->yuvPlanes[AVIF_CHAN_V],
-                                   image->yuvRowBytes[AVIF_CHAN_V],
-                                   rgb->pixels,
-                                   rgb->rowBytes,
-                                   matrixYUV,
-                                   image->width,
-                                   image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-        }
-    } else if (rgb->format == AVIF_RGB_FORMAT_BGRA) {
-        // AVIF_RGB_FORMAT_BGRA  *ToARGBMatrix   matrixYUV
-
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) {
-            if (I444ToARGBMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422) {
-#if LIBYUV_VERSION >= 1813
-            if (I422ToARGBMatrixFilter(image->yuvPlanes[AVIF_CHAN_Y],
-                                       image->yuvRowBytes[AVIF_CHAN_Y],
-                                       image->yuvPlanes[AVIF_CHAN_U],
-                                       image->yuvRowBytes[AVIF_CHAN_U],
-                                       image->yuvPlanes[AVIF_CHAN_V],
-                                       image->yuvRowBytes[AVIF_CHAN_V],
-                                       rgb->pixels,
-                                       rgb->rowBytes,
-                                       matrixYUV,
-                                       image->width,
-                                       image->height,
-                                       filter) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#else
-            if (I422ToARGBMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#endif
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-#if LIBYUV_VERSION >= 1813
-            if (I420ToARGBMatrixFilter(image->yuvPlanes[AVIF_CHAN_Y],
-                                       image->yuvRowBytes[AVIF_CHAN_Y],
-                                       image->yuvPlanes[AVIF_CHAN_U],
-                                       image->yuvRowBytes[AVIF_CHAN_U],
-                                       image->yuvPlanes[AVIF_CHAN_V],
-                                       image->yuvRowBytes[AVIF_CHAN_V],
-                                       rgb->pixels,
-                                       rgb->rowBytes,
-                                       matrixYUV,
-                                       image->width,
-                                       image->height,
-                                       filter) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#else
-            if (I420ToARGBMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#endif
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
-#if LIBYUV_VERSION >= 1756
-            if (I400ToARGBMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-#endif
-        }
-    } else if (rgb->format == AVIF_RGB_FORMAT_RGBA) {
-        // AVIF_RGB_FORMAT_RGBA  *ToARGBMatrix   matrixYVU
-
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) {
-            if (I444ToARGBMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422) {
-#if LIBYUV_VERSION >= 1813
-            if (I422ToARGBMatrixFilter(image->yuvPlanes[AVIF_CHAN_Y],
-                                       image->yuvRowBytes[AVIF_CHAN_Y],
-                                       image->yuvPlanes[AVIF_CHAN_V],
-                                       image->yuvRowBytes[AVIF_CHAN_V],
-                                       image->yuvPlanes[AVIF_CHAN_U],
-                                       image->yuvRowBytes[AVIF_CHAN_U],
-                                       rgb->pixels,
-                                       rgb->rowBytes,
-                                       matrixYVU,
-                                       image->width,
-                                       image->height,
-                                       filter) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#else
-            if (I422ToARGBMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#endif
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-#if LIBYUV_VERSION >= 1813
-            if (I420ToARGBMatrixFilter(image->yuvPlanes[AVIF_CHAN_Y],
-                                       image->yuvRowBytes[AVIF_CHAN_Y],
-                                       image->yuvPlanes[AVIF_CHAN_V],
-                                       image->yuvRowBytes[AVIF_CHAN_V],
-                                       image->yuvPlanes[AVIF_CHAN_U],
-                                       image->yuvRowBytes[AVIF_CHAN_U],
-                                       rgb->pixels,
-                                       rgb->rowBytes,
-                                       matrixYVU,
-                                       image->width,
-                                       image->height,
-                                       filter) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#else
-            if (I420ToARGBMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#endif
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
-#if LIBYUV_VERSION >= 1756
-            if (I400ToARGBMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-#endif
-        }
-    } else if (rgb->format == AVIF_RGB_FORMAT_ABGR) {
-        // AVIF_RGB_FORMAT_ABGR  *ToRGBAMatrix   matrixYUV
-
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) {
-            // This doesn't currently exist in libyuv
-#if 0
-            if (I444ToRGBAMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-#endif
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422) {
-            if (I422ToRGBAMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-            if (I420ToRGBAMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
-            // This doesn't currently exist in libyuv
-#if 0
-            if (I400ToRGBAMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-#endif
-        }
-    } else if (rgb->format == AVIF_RGB_FORMAT_ARGB) {
-        // AVIF_RGB_FORMAT_ARGB  *ToRGBAMatrix   matrixYVU
-
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) {
-            // This doesn't currently exist in libyuv
-#if 0
-            if (I444ToRGBAMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-#endif
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422) {
-            if (I422ToRGBAMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-            if (I420ToRGBAMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V],
-                                 image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
-            // This doesn't currently exist in libyuv
-#if 0
-            if (I400ToRGBAMatrix(image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y],
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-#endif
         }
     }
 
@@ -788,207 +513,99 @@
 
     assert((image->depth == 10) && (rgb->depth == 8));
 
-#if LIBYUV_VERSION >= 1813
-    enum FilterMode filter = kFilterBilinear;
-    if (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_FASTEST) {
-        // 'None' (Nearest neighbor) filter is faster than bilinear.
-        filter = kFilterNone;
-    }
-#endif
-
-    // This following section might be a bit complicated to audit without a bit of explanation:
-    //
     // libavif uses byte-order when describing pixel formats, such that the R in RGBA is the lowest address,
     // similar to PNG. libyuv orders in word-order, so libavif's RGBA would be referred to in libyuv as ABGR.
     // In addition, swapping U and V in any of these calls, along with using the Yvu matrix instead of Yuv matrix,
-    // swaps B and R in these orderings as well. This table summarizes this block's intent:
+    // swaps B and R in these orderings as well. This table summarizes the lookup tables that follow:
     //
     // libavif format        libyuv Func     UV matrix (and UV argument ordering)
     // --------------------  -------------   ------------------------------------
     // AVIF_RGB_FORMAT_RGB   n/a             n/a
+    // AVIF_RGB_FORMAT_RGBA  *ToARGBMatrix   matrixYVU
+    // AVIF_RGB_FORMAT_ARGB  n/a             n/a
     // AVIF_RGB_FORMAT_BGR   n/a             n/a
     // AVIF_RGB_FORMAT_BGRA  *ToARGBMatrix   matrixYUV
-    // AVIF_RGB_FORMAT_RGBA  *ToARGBMatrix   matrixYVU
-    // AVIF_RGB_FORMAT_ABGR  *ToRGBAMatrix   matrixYUV
-    // AVIF_RGB_FORMAT_ARGB  *ToRGBAMatrix   matrixYVU
+    // AVIF_RGB_FORMAT_ABGR  n/a             n/a
+    // AVIF_RGB_FORMAT_565   n/a             n/a
 
-    if (rgb->format == AVIF_RGB_FORMAT_BGRA) {
-        // AVIF_RGB_FORMAT_BGRA  *ToARGBMatrix   matrixYUV
+    avifBool isYVU = lutIsYVU[rgb->format];
+    const struct YuvConstants * matrix = isYVU ? matrixYVU : matrixYUV;
+    int uPlaneIndex = isYVU ? AVIF_CHAN_V : AVIF_CHAN_U;
+    int vPlaneIndex = isYVU ? AVIF_CHAN_U : AVIF_CHAN_V;
 
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) {
-#if LIBYUV_VERSION >= 1780
-            if (I410ToARGBMatrix((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
+    // Lookup table for YUV To RGB Matrix (with filter).
+    typedef int (*YUVToRGBMatrixFilter)(const uint16_t *,
+                                        int,
+                                        const uint16_t *,
+                                        int,
+                                        const uint16_t *,
+                                        int,
+                                        uint8_t *,
+                                        int,
+                                        const struct YuvConstants *,
+                                        int,
+                                        int,
+                                        enum FilterMode);
+    YUVToRGBMatrixFilter lutYuvToRgbMatrixFilter[AVIF_RGB_FORMAT_COUNT][AVIF_PIXEL_FORMAT_COUNT] = {
+        { NULL, NULL, NULL, NULL, NULL },                                     // RGB
+        { NULL, NULL, I210ToARGBMatrixFilter, I010ToARGBMatrixFilter, NULL }, // RGBA
+        { NULL, NULL, NULL, NULL, NULL },                                     // ARGB
+        { NULL, NULL, NULL, NULL, NULL },                                     // BGR
+        { NULL, NULL, I210ToARGBMatrixFilter, I010ToARGBMatrixFilter, NULL }, // BGRA
+        { NULL, NULL, NULL, NULL, NULL },                                     // ABGR
+        { NULL, NULL, NULL, NULL, NULL },                                     // RGB_565
+    };
+    YUVToRGBMatrixFilter yuvToRgbMatrixFilter = lutYuvToRgbMatrixFilter[rgb->format][image->yuvFormat];
+    if (yuvToRgbMatrixFilter != NULL) {
+        // 'None' (Nearest neighbor) filter is faster than bilinear.
+        enum FilterMode filter = (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_FASTEST) ? kFilterNone : kFilterBilinear;
+        if (yuvToRgbMatrixFilter((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
                                  image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V] / 2,
+                                 (const uint16_t *)image->yuvPlanes[uPlaneIndex],
+                                 image->yuvRowBytes[uPlaneIndex] / 2,
+                                 (const uint16_t *)image->yuvPlanes[vPlaneIndex],
+                                 image->yuvRowBytes[vPlaneIndex] / 2,
                                  rgb->pixels,
                                  rgb->rowBytes,
-                                 matrixYUV,
+                                 matrix,
                                  image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-#endif
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422) {
-#if LIBYUV_VERSION >= 1813
-            if (I210ToARGBMatrixFilter((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                       image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                       (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                       image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                       (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                       image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                       rgb->pixels,
-                                       rgb->rowBytes,
-                                       matrixYUV,
-                                       image->width,
-                                       image->height,
-                                       filter) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#else
-            if (I210ToARGBMatrix((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#endif
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-#if LIBYUV_VERSION >= 1813
-            if (I010ToARGBMatrixFilter((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                       image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                       (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                       image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                       (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                       image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                       rgb->pixels,
-                                       rgb->rowBytes,
-                                       matrixYUV,
-                                       image->width,
-                                       image->height,
-                                       filter) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#else
-            if (I010ToARGBMatrix((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYUV,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#endif
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
-            // This doesn't currently exist in libyuv
+                                 image->height,
+                                 filter) != 0) {
+            return AVIF_RESULT_REFORMAT_FAILED;
         }
-    } else if (rgb->format == AVIF_RGB_FORMAT_RGBA) {
-        // AVIF_RGB_FORMAT_RGBA  *ToARGBMatrix   matrixYVU
-
-        if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) {
-#if LIBYUV_VERSION >= 1780
-            if (I410ToARGBMatrix((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-            return AVIF_RESULT_OK;
-#endif
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422) {
-#if LIBYUV_VERSION >= 1813
-            if (I210ToARGBMatrixFilter((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                       image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                       (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                       image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                       (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                       image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                       rgb->pixels,
-                                       rgb->rowBytes,
-                                       matrixYVU,
-                                       image->width,
-                                       image->height,
-                                       filter) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#else
-            if (I210ToARGBMatrix((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#endif
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
-#if LIBYUV_VERSION >= 1813
-            if (I010ToARGBMatrixFilter((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                       image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                       (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                       image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                       (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                       image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                       rgb->pixels,
-                                       rgb->rowBytes,
-                                       matrixYVU,
-                                       image->width,
-                                       image->height,
-                                       filter) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#else
-            if (I010ToARGBMatrix((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
-                                 image->yuvRowBytes[AVIF_CHAN_Y] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_V],
-                                 image->yuvRowBytes[AVIF_CHAN_V] / 2,
-                                 (const uint16_t *)image->yuvPlanes[AVIF_CHAN_U],
-                                 image->yuvRowBytes[AVIF_CHAN_U] / 2,
-                                 rgb->pixels,
-                                 rgb->rowBytes,
-                                 matrixYVU,
-                                 image->width,
-                                 image->height) != 0) {
-                return AVIF_RESULT_REFORMAT_FAILED;
-            }
-#endif
-            return AVIF_RESULT_OK;
-        } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
-            // This doesn't currently exist in libyuv
-        }
+        return AVIF_RESULT_OK;
     }
 
-    // This function didn't do anything; use the built-in YUV conversion
+    // Lookup table for YUV To RGB Matrix (without filter).
+    typedef int (
+        *YUVToRGBMatrix)(const uint16_t *, int, const uint16_t *, int, const uint16_t *, int, uint8_t *, int, const struct YuvConstants *, int, int);
+    YUVToRGBMatrix lutYuvToRgbMatrix[AVIF_RGB_FORMAT_COUNT][AVIF_PIXEL_FORMAT_COUNT] = {
+        { NULL, NULL, NULL, NULL, NULL },                                     // RGB
+        { NULL, I410ToARGBMatrix, I210ToARGBMatrix, I010ToARGBMatrix, NULL }, // RGBA
+        { NULL, NULL, NULL, NULL, NULL },                                     // ARGB
+        { NULL, NULL, NULL, NULL, NULL },                                     // BGR
+        { NULL, I410ToARGBMatrix, I210ToARGBMatrix, I010ToARGBMatrix, NULL }, // BGRA
+        { NULL, NULL, NULL, NULL, NULL },                                     // ABGR
+        { NULL, NULL, NULL, NULL, NULL },                                     // RGB_565
+    };
+    YUVToRGBMatrix yuvToRgbMatrix = lutYuvToRgbMatrix[rgb->format][image->yuvFormat];
+    if (yuvToRgbMatrix != NULL) {
+        if (yuvToRgbMatrix((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
+                           image->yuvRowBytes[AVIF_CHAN_Y] / 2,
+                           (const uint16_t *)image->yuvPlanes[uPlaneIndex],
+                           image->yuvRowBytes[uPlaneIndex] / 2,
+                           (const uint16_t *)image->yuvPlanes[vPlaneIndex],
+                           image->yuvRowBytes[vPlaneIndex] / 2,
+                           rgb->pixels,
+                           rgb->rowBytes,
+                           matrix,
+                           image->width,
+                           image->height) != 0) {
+            return AVIF_RESULT_REFORMAT_FAILED;
+        }
+        return AVIF_RESULT_OK;
+    }
+
     return AVIF_RESULT_NOT_IMPLEMENTED;
 }
 
diff --git a/tests/avifyuv.c b/tests/avifyuv.c
index 0c1a53a..b7e2df1 100644
--- a/tests/avifyuv.c
+++ b/tests/avifyuv.c
@@ -41,6 +41,8 @@
             return "ABGR";
         case AVIF_RGB_FORMAT_RGB_565:
             return "RGB_565";
+        case AVIF_RGB_FORMAT_COUNT:
+            break;
     }
     return "Unknown";
 }