diff --git a/CHANGELOG.md b/CHANGELOG.md
index 14fc6b9..ff86177 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,11 +7,11 @@
 ## [Unreleased]
 
 There are incompatible ABI changes in this release. The alphaRange member was
-removed from avifImage struct. The chromaDownsampling member was added to the
-avifRGBImage struct. The imageDimensionLimit member was added to the avifDecoder
-struct. avifImageCopy() and avifImageAllocatePlanes() signatures changed. It is
-necessary to recompile your code. Also check the return values of
-avifImageCopy() and avifImageAllocatePlanes().
+removed from avifImage struct. The chromaDownsampling and avoidLibYUV members
+were added to the avifRGBImage struct. The imageDimensionLimit member was added
+to the avifDecoder struct. avifImageCopy() and avifImageAllocatePlanes()
+signatures changed. It is necessary to recompile your code. Also check the
+return values of avifImageCopy() and avifImageAllocatePlanes().
 
 ### Changed
 * Update aom.cmd: v3.4.0
@@ -23,7 +23,10 @@
   void to report invalid parameters or memory allocation failures.
 * avifImageRGBToYUV() now uses libyuv fast paths by default. It may slightly
   change conversion results. The old behavior can be restored by setting
-  avifRGBImage::chromaDownsampling to AVIF_CHROMA_DOWNSAMPLING_BEST_QUALITY.
+  avifRGBImage::chromaDownsampling to AVIF_CHROMA_DOWNSAMPLING_BEST_QUALITY
+  and avifRGBImage::avoidLibYUV to AVIF_TRUE.
+* avifRGBImage::chromaUpsampling now only applies to conversions that need
+  upsampling chroma from 4:2:0 or 4:2:2 and has no impact on the use of libyuv.
 
 ### Removed
 * alphaRange field was removed from the avifImage struct. It it presumed that
@@ -34,6 +37,7 @@
 * Add chromaDownsampling field to avifRGBImage struct
 * Add imageDimensionLimit field to avifDecoder struct
 * Add autoTiling field to avifEncoder struct
+* Add AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV value to avifChromaDownsampling enum
 * avifdec: Add --dimension-limit, which specifies the image dimension limit
   (width or height) that should be tolerated
 * avifenc: Add --sharpyuv, which enables "sharp" RGB to YUV420 conversion, which
diff --git a/android_jni/avifandroidjni/src/main/jni/libavif_jni.cc b/android_jni/avifandroidjni/src/main/jni/libavif_jni.cc
index 6d0e060..6284870 100644
--- a/android_jni/avifandroidjni/src/main/jni/libavif_jni.cc
+++ b/android_jni/avifandroidjni/src/main/jni/libavif_jni.cc
@@ -166,8 +166,7 @@
   }
   rgb_image.pixels = static_cast<uint8_t*>(bitmap_pixels);
   rgb_image.rowBytes = bitmap_info.stride;
-  res = avifImageYUVToRGB(decoder.decoder->image, &rgb_image,
-                          AVIF_YUV_TO_RGB_DEFAULT);
+  res = avifImageYUVToRGB(decoder.decoder->image, &rgb_image);
   AndroidBitmap_unlockPixels(env, bitmap);
   if (res != AVIF_RESULT_OK) {
     LOGE("Failed to convert YUV Pixels to RGB. Status: %d", res);
diff --git a/apps/avifdec.c b/apps/avifdec.c
index 27ab40d..004f681 100644
--- a/apps/avifdec.c
+++ b/apps/avifdec.c
@@ -62,7 +62,7 @@
     int pngCompressionLevel = -1; // -1 is a sentinel to avifPNGWrite() to skip calling png_set_compression_level()
     avifCodecChoice codecChoice = AVIF_CODEC_CHOICE_AUTO;
     avifBool infoOnly = AVIF_FALSE;
-    avifYUVToRGBFlags upsamplingFlags = AVIF_YUV_TO_RGB_DEFAULT;
+    avifChromaUpsampling upsamplingFlags = AVIF_CHROMA_UPSAMPLING_AUTOMATIC;
     avifBool ignoreICC = AVIF_FALSE;
     avifBool rawColor = AVIF_FALSE;
     avifBool allowProgressive = AVIF_FALSE;
@@ -153,11 +153,11 @@
         } else if (!strcmp(arg, "-u") || !strcmp(arg, "--upsampling")) {
             NEXTARG();
             if (!strcmp(arg, "automatic")) {
-                upsamplingFlags = AVIF_YUV_TO_RGB_DEFAULT;
+                upsamplingFlags = AVIF_CHROMA_UPSAMPLING_AUTOMATIC;
             } else if (!strcmp(arg, "fastest")) {
-                upsamplingFlags = AVIF_CHROMA_UPSAMPLING_NEAREST;
+                upsamplingFlags = AVIF_CHROMA_UPSAMPLING_FASTEST;
             } else if (!strcmp(arg, "best")) {
-                upsamplingFlags = AVIF_YUV_TO_RGB_AVOID_LIBYUV | AVIF_CHROMA_UPSAMPLING_BILINEAR;
+                upsamplingFlags = AVIF_CHROMA_UPSAMPLING_BEST_QUALITY;
             } else if (!strcmp(arg, "nearest")) {
                 upsamplingFlags = AVIF_CHROMA_UPSAMPLING_NEAREST;
             } else if (!strcmp(arg, "bilinear")) {
diff --git a/apps/avifenc.c b/apps/avifenc.c
index 199f841..918d521 100644
--- a/apps/avifenc.c
+++ b/apps/avifenc.c
@@ -266,7 +266,7 @@
                                             avifImage * image,
                                             uint32_t * outDepth,
                                             avifAppSourceTiming * sourceTiming,
-                                            avifRGBToYUVFlags flags)
+                                            avifChromaDownsampling flags)
 {
     if (sourceTiming) {
         // A source timing of all 0s is a sentinel value hinting that the value is unset / should be
@@ -484,7 +484,7 @@
     avifColorPrimaries colorPrimaries = AVIF_COLOR_PRIMARIES_UNSPECIFIED;
     avifTransferCharacteristics transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED;
     avifMatrixCoefficients matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT601;
-    avifRGBToYUVFlags flags = AVIF_RGB_TO_YUV_DEFAULT;
+    avifChromaDownsampling flags = AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC;
 
     int argIndex = 1;
     while (argIndex < argc) {
diff --git a/apps/shared/avifjpeg.c b/apps/shared/avifjpeg.c
index 4cb54ba..2e2bd60 100644
--- a/apps/shared/avifjpeg.c
+++ b/apps/shared/avifjpeg.c
@@ -243,7 +243,7 @@
                       avifImage * avif,
                       avifPixelFormat requestedFormat,
                       uint32_t requestedDepth,
-                      avifRGBToYUVFlags flags,
+                      avifChromaDownsampling flags,
                       avifBool ignoreICC,
                       avifBool ignoreExif,
                       avifBool ignoreXMP)
@@ -318,6 +318,7 @@
         avif->depth = requestedDepth ? requestedDepth : 8;
         avifRGBImageSetDefaults(&rgb, avif);
         rgb.format = AVIF_RGB_FORMAT_RGB;
+        rgb.chromaDownsampling = flags;
         rgb.depth = 8;
         avifRGBImageAllocatePixels(&rgb);
 
@@ -328,7 +329,7 @@
             memcpy(pixelRow, buffer[0], rgb.rowBytes);
             ++row;
         }
-        if (avifImageRGBToYUV(avif, &rgb, flags) != AVIF_RESULT_OK) {
+        if (avifImageRGBToYUV(avif, &rgb) != AVIF_RESULT_OK) {
             fprintf(stderr, "Conversion to YUV failed: %s\n", inputFilename);
             goto cleanup;
         }
@@ -381,7 +382,7 @@
     return ret;
 }
 
-avifBool avifJPEGWrite(const char * outputFilename, const avifImage * avif, int jpegQuality, avifYUVToRGBFlags conversionFlags)
+avifBool avifJPEGWrite(const char * outputFilename, const avifImage * avif, int jpegQuality, avifChromaUpsampling flags)
 {
     avifBool ret = AVIF_FALSE;
     FILE * f = NULL;
@@ -395,9 +396,10 @@
     avifRGBImage rgb;
     avifRGBImageSetDefaults(&rgb, avif);
     rgb.format = AVIF_RGB_FORMAT_RGB;
+    rgb.chromaUpsampling = flags;
     rgb.depth = 8;
     avifRGBImageAllocatePixels(&rgb);
-    if (avifImageYUVToRGB(avif, &rgb, conversionFlags) != AVIF_RESULT_OK) {
+    if (avifImageYUVToRGB(avif, &rgb) != AVIF_RESULT_OK) {
         fprintf(stderr, "Conversion to RGB failed: %s\n", outputFilename);
         goto cleanup;
     }
diff --git a/apps/shared/avifjpeg.h b/apps/shared/avifjpeg.h
index 214bcca..6611063 100644
--- a/apps/shared/avifjpeg.h
+++ b/apps/shared/avifjpeg.h
@@ -14,11 +14,11 @@
                       avifImage * avif,
                       avifPixelFormat requestedFormat,
                       uint32_t requestedDepth,
-                      avifRGBToYUVFlags flags,
+                      avifChromaDownsampling flags,
                       avifBool ignoreICC,
                       avifBool ignoreExif,
                       avifBool ignoreXMP);
-avifBool avifJPEGWrite(const char * outputFilename, const avifImage * avif, int jpegQuality, avifYUVToRGBFlags conversionFlags);
+avifBool avifJPEGWrite(const char * outputFilename, const avifImage * avif, int jpegQuality, avifChromaUpsampling flags);
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/apps/shared/avifpng.c b/apps/shared/avifpng.c
index 873cb39..d40ab1a 100644
--- a/apps/shared/avifpng.c
+++ b/apps/shared/avifpng.c
@@ -205,7 +205,7 @@
                      avifImage * avif,
                      avifPixelFormat requestedFormat,
                      uint32_t requestedDepth,
-                     avifRGBToYUVFlags flags,
+                     avifChromaDownsampling flags,
                      avifBool ignoreICC,
                      avifBool ignoreExif,
                      avifBool ignoreXMP,
@@ -328,6 +328,7 @@
     }
 
     avifRGBImageSetDefaults(&rgb, avif);
+    rgb.chromaDownsampling = flags;
     rgb.depth = imgBitDepth;
     avifRGBImageAllocatePixels(&rgb);
     rowPointers = (png_bytep *)malloc(sizeof(png_bytep) * rgb.height);
@@ -335,7 +336,7 @@
         rowPointers[y] = &rgb.pixels[y * rgb.rowBytes];
     }
     png_read_image(png, rowPointers);
-    if (avifImageRGBToYUV(avif, &rgb, flags) != AVIF_RESULT_OK) {
+    if (avifImageRGBToYUV(avif, &rgb) != AVIF_RESULT_OK) {
         fprintf(stderr, "Conversion to YUV failed: %s\n", inputFilename);
         goto cleanup;
     }
@@ -367,7 +368,7 @@
     return readResult;
 }
 
-avifBool avifPNGWrite(const char * outputFilename, const avifImage * avif, uint32_t requestedDepth, avifYUVToRGBFlags conversionFlags, int compressionLevel)
+avifBool avifPNGWrite(const char * outputFilename, const avifImage * avif, uint32_t requestedDepth, avifChromaUpsampling flags, int compressionLevel)
 {
     volatile avifBool writeResult = AVIF_FALSE;
     png_structp png = NULL;
@@ -388,6 +389,7 @@
     }
 
     avifRGBImageSetDefaults(&rgb, avif);
+    rgb.chromaUpsampling = flags;
     rgb.depth = rgbDepth;
     int colorType = PNG_COLOR_TYPE_RGBA;
     if (!avif->alphaPlane) {
@@ -395,7 +397,7 @@
         rgb.format = AVIF_RGB_FORMAT_RGB;
     }
     avifRGBImageAllocatePixels(&rgb);
-    if (avifImageYUVToRGB(avif, &rgb, conversionFlags) != AVIF_RESULT_OK) {
+    if (avifImageYUVToRGB(avif, &rgb) != AVIF_RESULT_OK) {
         fprintf(stderr, "Conversion to RGB failed: %s\n", outputFilename);
         goto cleanup;
     }
diff --git a/apps/shared/avifpng.h b/apps/shared/avifpng.h
index 9597211..cd52e29 100644
--- a/apps/shared/avifpng.h
+++ b/apps/shared/avifpng.h
@@ -15,16 +15,12 @@
                      avifImage * avif,
                      avifPixelFormat requestedFormat,
                      uint32_t requestedDepth,
-                     avifRGBToYUVFlags flags,
+                     avifChromaDownsampling flags,
                      avifBool ignoreICC,
                      avifBool ignoreExif,
                      avifBool ignoreXMP,
                      uint32_t * outPNGDepth);
-avifBool avifPNGWrite(const char * outputFilename,
-                      const avifImage * avif,
-                      uint32_t requestedDepth,
-                      avifYUVToRGBFlags conversionFlags,
-                      int compressionLevel);
+avifBool avifPNGWrite(const char * outputFilename, const avifImage * avif, uint32_t requestedDepth, avifChromaUpsampling flags, int compressionLevel);
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/apps/shared/avifutil.c b/apps/shared/avifutil.c
index c0c4470..7d2db88 100644
--- a/apps/shared/avifutil.c
+++ b/apps/shared/avifutil.c
@@ -227,7 +227,7 @@
 avifAppFileFormat avifReadImage(const char * filename,
                                 avifPixelFormat requestedFormat,
                                 int requestedDepth,
-                                avifRGBToYUVFlags flags,
+                                avifChromaDownsampling flags,
                                 avifBool ignoreICC,
                                 avifBool ignoreExif,
                                 avifBool ignoreXMP,
diff --git a/apps/shared/avifutil.h b/apps/shared/avifutil.h
index c1b77cd..d6da3fe 100644
--- a/apps/shared/avifutil.h
+++ b/apps/shared/avifutil.h
@@ -63,7 +63,7 @@
 avifAppFileFormat avifReadImage(const char * filename,
                                 avifPixelFormat requestedFormat,
                                 int requestedDepth,
-                                avifRGBToYUVFlags flags,
+                                avifChromaDownsampling flags,
                                 avifBool ignoreICC,
                                 avifBool ignoreExif,
                                 avifBool ignoreXMP,
diff --git a/contrib/gdk-pixbuf/loader.c b/contrib/gdk-pixbuf/loader.c
index c9a760b..32c6eee 100644
--- a/contrib/gdk-pixbuf/loader.c
+++ b/contrib/gdk-pixbuf/loader.c
@@ -124,7 +124,7 @@
     rgb.pixels = gdk_pixbuf_get_pixels(output);
     rgb.rowBytes = gdk_pixbuf_get_rowstride(output);
 
-    ret = avifImageYUVToRGB(image, &rgb, AVIF_YUV_TO_RGB_DEFAULT);
+    ret = avifImageYUVToRGB(image, &rgb);
     if (ret != AVIF_RESULT_OK) {
         g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_FAILED,
                     "Failed to convert YUV to RGB: %s", avifResultToString(ret));
@@ -448,7 +448,7 @@
         rgb.format = AVIF_RGB_FORMAT_RGB;
     }
 
-    res = avifImageRGBToYUV(avif, &rgb, AVIF_RGB_TO_YUV_DEFAULT);
+    res = avifImageRGBToYUV(avif, &rgb);
     if ( res != AVIF_RESULT_OK ) {
         g_set_error(error,
                     GDK_PIXBUF_ERROR,
diff --git a/examples/avif_example_decode_file.c b/examples/avif_example_decode_file.c
index 1f8d1fa..f3fafb9 100644
--- a/examples/avif_example_decode_file.c
+++ b/examples/avif_example_decode_file.c
@@ -53,14 +53,14 @@
         // * this frame's sequence timing
 
         avifRGBImageSetDefaults(&rgb, decoder->image);
-        // Override YUV(A)->RGB(A) defaults here: depth, format, ignoreAlpha, alphaPremultiplied, etc
+        // Override YUV(A)->RGB(A) defaults here:
+        //   depth, format, chromaUpsampling, avoidLibYUV, ignoreAlpha, alphaPremultiplied, etc.
 
         // Alternative: set rgb.pixels and rgb.rowBytes yourself, which should match your chosen rgb.format
         // Be sure to use uint16_t* instead of uint8_t* for rgb.pixels/rgb.rowBytes if (rgb.depth > 8)
         avifRGBImageAllocatePixels(&rgb);
 
-        // Other flags than AVIF_YUV_TO_RGB_DEFAULT, such as AVIF_CHROMA_UPSAMPLING_NEAREST, can be passed.
-        if (avifImageYUVToRGB(decoder->image, &rgb, AVIF_YUV_TO_RGB_DEFAULT) != AVIF_RESULT_OK) {
+        if (avifImageYUVToRGB(decoder->image, &rgb) != AVIF_RESULT_OK) {
             fprintf(stderr, "Conversion from YUV failed: %s\n", inputFilename);
             goto cleanup;
         }
diff --git a/examples/avif_example_decode_memory.c b/examples/avif_example_decode_memory.c
index d5a9aa9..2cf4a0b 100644
--- a/examples/avif_example_decode_memory.c
+++ b/examples/avif_example_decode_memory.c
@@ -75,14 +75,14 @@
         // * this frame's sequence timing
 
         avifRGBImageSetDefaults(&rgb, decoder->image);
-        // Override YUV(A)->RGB(A) defaults here: depth, format, ignoreAlpha, alphaPremultiplied, etc
+        // Override YUV(A)->RGB(A) defaults here:
+        //   depth, format, chromaUpsampling, avoidLibYUV, ignoreAlpha, alphaPremultiplied, etc.
 
         // Alternative: set rgb.pixels and rgb.rowBytes yourself, which should match your chosen rgb.format
         // Be sure to use uint16_t* instead of uint8_t* for rgb.pixels/rgb.rowBytes if (rgb.depth > 8)
         avifRGBImageAllocatePixels(&rgb);
 
-        // Other flags than AVIF_YUV_TO_RGB_DEFAULT, such as AVIF_CHROMA_UPSAMPLING_NEAREST, can be passed.
-        if (avifImageYUVToRGB(decoder->image, &rgb, AVIF_YUV_TO_RGB_DEFAULT) != AVIF_RESULT_OK) {
+        if (avifImageYUVToRGB(decoder->image, &rgb) != AVIF_RESULT_OK) {
             fprintf(stderr, "Conversion from YUV failed: %s\n", inputFilename);
             goto cleanup;
         }
diff --git a/examples/avif_example_encode.c b/examples/avif_example_encode.c
index b95cf0a..34b6cdc 100644
--- a/examples/avif_example_encode.c
+++ b/examples/avif_example_encode.c
@@ -57,7 +57,8 @@
         printf("Encoding from converted RGBA\n");
 
         avifRGBImageSetDefaults(&rgb, image);
-        // Override RGB(A)->YUV(A) defaults here: depth, format, ignoreAlpha, alphaPremultiplied, etc
+        // Override RGB(A)->YUV(A) defaults here:
+        //   depth, format, chromaDownsampling, avoidLibYUV, ignoreAlpha, alphaPremultiplied, etc.
 
         // Alternative: set rgb.pixels and rgb.rowBytes yourself, which should match your chosen rgb.format
         // Be sure to use uint16_t* instead of uint8_t* for rgb.pixels/rgb.rowBytes if (rgb.depth > 8)
@@ -66,8 +67,7 @@
         // Fill your RGB(A) data here
         memset(rgb.pixels, 255, rgb.rowBytes * image->height);
 
-        // Other flags than AVIF_RGB_TO_YUV_DEFAULT, such as AVIF_RGB_TO_YUV_AVOID_LIBYUV, can be passed.
-        avifResult convertResult = avifImageRGBToYUV(image, &rgb, AVIF_RGB_TO_YUV_DEFAULT);
+        avifResult convertResult = avifImageRGBToYUV(image, &rgb);
         if (convertResult != AVIF_RESULT_OK) {
             fprintf(stderr, "Failed to convert to YUV(A): %s\n", avifResultToString(convertResult));
             goto cleanup;
diff --git a/include/avif/avif.h b/include/avif/avif.h
index a946d94..9e0203d 100644
--- a/include/avif/avif.h
+++ b/include/avif/avif.h
@@ -530,6 +530,9 @@
 
 // If libavif is built with a version of libyuv offering a fast conversion between RGB and YUV for
 // the given inputs, libavif will use it. See reformat_libyuv.c for the details.
+// libyuv is faster but may have slightly less precision than built-in conversion, so avoidLibYUV
+// should be set to AVIF_TRUE when AVIF_CHROMA_UPSAMPLING_BEST_QUALITY or
+// AVIF_CHROMA_DOWNSAMPLING_BEST_QUALITY is used, to get the most precise but slowest results.
 
 // Note to libavif maintainers: The lookup tables in avifImageYUVToRGBLibYUV
 // rely on the ordering of this enum values for their correctness. So changing
@@ -558,14 +561,39 @@
 AVIF_API uint32_t avifRGBFormatChannelCount(avifRGBFormat format);
 AVIF_API avifBool avifRGBFormatHasAlpha(avifRGBFormat format);
 
+typedef enum avifChromaUpsampling
+{
+    AVIF_CHROMA_UPSAMPLING_AUTOMATIC = 0,    // Chooses best trade off of speed/quality (uses BILINEAR libyuv if available,
+                                             // or fallbacks to NEAREST libyuv if available, or fallbacks to BILINEAR built-in)
+    AVIF_CHROMA_UPSAMPLING_FASTEST = 1,      // Chooses speed over quality (same as NEAREST)
+    AVIF_CHROMA_UPSAMPLING_BEST_QUALITY = 2, // Chooses the best quality upsampling, given settings (same as BILINEAR)
+    AVIF_CHROMA_UPSAMPLING_NEAREST = 3,      // Uses nearest-neighbor filter
+    AVIF_CHROMA_UPSAMPLING_BILINEAR = 4      // Uses bilinear filter
+} avifChromaUpsampling;
+
+typedef enum avifChromaDownsampling
+{
+    AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC = 0,    // Chooses best trade off of speed/quality (same as AVERAGE)
+    AVIF_CHROMA_DOWNSAMPLING_FASTEST = 1,      // Chooses speed over quality (same as AVERAGE)
+    AVIF_CHROMA_DOWNSAMPLING_BEST_QUALITY = 2, // Chooses the best quality upsampling (same as AVERAGE)
+    AVIF_CHROMA_DOWNSAMPLING_AVERAGE = 3,      // Uses averaging filter
+    AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV = 4     // Uses sharp yuv filter (libsharpyuv), available for 4:2:0 only, ignored for 4:2:2
+} avifChromaDownsampling;
+
 typedef struct avifRGBImage
 {
-    uint32_t width;              // must match associated avifImage
-    uint32_t height;             // must match associated avifImage
-    uint32_t depth;              // legal depths [8, 10, 12, 16]. if depth>8, pixels must be uint16_t internally
-    avifRGBFormat format;        // all channels are always full range
-    avifBool ignoreAlpha;        // Used for XRGB formats, treats formats containing alpha (such as ARGB) as if they were
-                                 // RGB, treating the alpha bits as if they were all 1.
+    uint32_t width;                        // must match associated avifImage
+    uint32_t height;                       // must match associated avifImage
+    uint32_t depth;                        // legal depths [8, 10, 12, 16]. if depth>8, pixels must be uint16_t internally
+    avifRGBFormat format;                  // all channels are always full range
+    avifChromaUpsampling chromaUpsampling; // How to upsample from 4:2:0 or 4:2:2 UV when converting to RGB (ignored for 4:4:4 and 4:0:0).
+                                           // Ignored when converting to YUV. Defaults to AVIF_CHROMA_UPSAMPLING_AUTOMATIC.
+    avifChromaDownsampling chromaDownsampling; // How to downsample to 4:2:0 or 4:2:2 UV when converting from RGB (ignored for 4:4:4 and 4:0:0).
+                                               // Ignored when converting to RGB. Defaults to AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC.
+    avifBool avoidLibYUV; // If AVIF_FALSE and libyuv conversion between RGB and YUV (including upsampling or downsampling if any)
+                          // is available for the avifImage/avifRGBImage combination, then libyuv is used. Default is AVIF_FALSE.
+    avifBool ignoreAlpha; // Used for XRGB formats, treats formats containing alpha (such as ARGB) as if they were RGB, treating
+                          // the alpha bits as if they were all 1.
     avifBool alphaPremultiplied; // indicates if RGB value is pre-multiplied by alpha. Default: false
     avifBool isFloat; // indicates if RGBA values are in half float (f16) format. Valid only when depth == 16. Default: false
 
@@ -583,44 +611,9 @@
 AVIF_API void avifRGBImageAllocatePixels(avifRGBImage * rgb);
 AVIF_API void avifRGBImageFreePixels(avifRGBImage * rgb);
 
-// Conversion options.
-typedef enum avifRGBToYUVFlag
-{
-    AVIF_RGB_TO_YUV_DEFAULT = 0, // Uses the first available downsampling filter among:
-                                 //   libyuv average, built-in average
-
-    // libyuv preference
-
-    AVIF_RGB_TO_YUV_AVOID_LIBYUV = (1 << 0), // Only picks built-in paths. The default is to prefer libyuv if available.
-
-    // Conversion from RGB to YUV 4:2:2 or YUV 4:2:0 (ignored in all other cases)
-
-    // Chroma downsampling filter. Set at most one:
-    AVIF_CHROMA_DOWNSAMPLING_AVERAGE = (1 << 10),   // only use the averaging filter (libyuv or built-in)
-    AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV = (1 << 11), // only use sharp yuv filter (libsharpyuv),
-                                                    // available for 4:2:0 only, ignored for 4:2:2
-} avifRGBToYUVFlag;
-typedef uint32_t avifRGBToYUVFlags;
-typedef enum avifYUVToRGBFlag
-{
-    AVIF_YUV_TO_RGB_DEFAULT = 0, // Uses the first available upsampling filter among:
-                                 //   libyuv bilinear, libyuv nearest-neighbor, built-in bilinear
-
-    // libyuv preference
-
-    AVIF_YUV_TO_RGB_AVOID_LIBYUV = (1 << 0), // Only picks built-in paths. The default is to prefer libyuv if available.
-
-    // Conversion from YUV 4:2:2 or YUV 4:2:0 to RGB (ignored in all other cases)
-
-    // Chroma upsampling filter. Set at most one:
-    AVIF_CHROMA_UPSAMPLING_NEAREST = (1 << 10), // only use the fast nearest-neighbor filter (libyuv or built-in)
-    AVIF_CHROMA_UPSAMPLING_BILINEAR = (1 << 11) // only use the good-quality bilinear filter (libyuv or built-in)
-} avifYUVToRGBFlag;
-typedef uint32_t avifYUVToRGBFlags;
-
-// Conversion functions.
-AVIF_API avifResult avifImageRGBToYUV(avifImage * image, const avifRGBImage * rgb, avifRGBToYUVFlags flags);
-AVIF_API avifResult avifImageYUVToRGB(const avifImage * image, avifRGBImage * rgb, avifYUVToRGBFlags flags);
+// The main conversion functions
+AVIF_API avifResult avifImageRGBToYUV(avifImage * image, const avifRGBImage * rgb);
+AVIF_API avifResult avifImageYUVToRGB(const avifImage * image, avifRGBImage * rgb);
 
 // Premultiply handling functions.
 // (Un)premultiply is automatically done by the main conversion functions above,
diff --git a/include/avif/internal.h b/include/avif/internal.h
index 283502d..5cc5aab 100644
--- a/include/avif/internal.h
+++ b/include/avif/internal.h
@@ -149,7 +149,7 @@
 // * AVIF_RESULT_OK              - Converted successfully with libyuv
 // * AVIF_RESULT_NOT_IMPLEMENTED - The fast path for this combination is not implemented with libyuv, use built-in YUV conversion
 // * [any other error]           - Return error to caller
-avifResult avifImageYUVToRGBLibYUV(const avifImage * image, avifRGBImage * rgb, avifYUVToRGBFlags flags);
+avifResult avifImageYUVToRGBLibYUV(const avifImage * image, avifRGBImage * rgb);
 
 // Returns:
 // * AVIF_RESULT_OK              - Converted successfully with libsharpyuv
diff --git a/src/avif.c b/src/avif.c
index d6e4afb..4ef4780 100644
--- a/src/avif.c
+++ b/src/avif.c
@@ -457,6 +457,9 @@
     rgb->height = image->height;
     rgb->depth = image->depth;
     rgb->format = AVIF_RGB_FORMAT_RGBA;
+    rgb->chromaUpsampling = AVIF_CHROMA_UPSAMPLING_AUTOMATIC;
+    rgb->chromaDownsampling = AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC;
+    rgb->avoidLibYUV = AVIF_FALSE;
     rgb->ignoreAlpha = AVIF_FALSE;
     rgb->pixels = NULL;
     rgb->rowBytes = 0;
diff --git a/src/reformat.c b/src/reformat.c
index d792a85..951c46b 100644
--- a/src/reformat.c
+++ b/src/reformat.c
@@ -194,7 +194,7 @@
     return AVIF_CLAMP(unorm, 0, state->yuvMaxChannel);
 }
 
-avifResult avifImageRGBToYUV(avifImage * image, const avifRGBImage * rgb, avifRGBToYUVFlags flags)
+avifResult avifImageRGBToYUV(avifImage * image, const avifRGBImage * rgb)
 {
     if (!rgb->pixels || rgb->format == AVIF_RGB_FORMAT_RGB_565) {
         return AVIF_RESULT_REFORMAT_FAILED;
@@ -227,7 +227,7 @@
     avifBool converted = AVIF_FALSE;
 
     // Try converting with libsharpyuv.
-    if ((flags & AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV) && image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
+    if ((rgb->chromaDownsampling == AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV) && (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420)) {
         const avifResult libSharpYUVResult = avifImageRGBToYUVLibSharpYUV(image, rgb, &state);
         if (libSharpYUVResult != AVIF_RESULT_OK) {
             // Return the error if sharpyuv was requested but failed for any reason, including libsharpyuv not being available.
@@ -236,7 +236,7 @@
         converted = AVIF_TRUE;
     }
 
-    if (!converted && !(flags & AVIF_RGB_TO_YUV_AVOID_LIBYUV) && (alphaMode == AVIF_ALPHA_MULTIPLY_MODE_NO_OP)) {
+    if (!converted && !rgb->avoidLibYUV && (alphaMode == AVIF_ALPHA_MULTIPLY_MODE_NO_OP)) {
         avifResult libyuvResult = avifImageRGBToYUVLibYUV(image, rgb);
         if (libyuvResult == AVIF_RESULT_OK) {
             converted = AVIF_TRUE;
@@ -479,7 +479,7 @@
 }
 
 // Note: This function handles alpha (un)multiply.
-static avifResult avifImageYUVAnyToRGBAnySlow(const avifImage * image, avifRGBImage * rgb, avifReformatState * state, avifYUVToRGBFlags flags)
+static avifResult avifImageYUVAnyToRGBAnySlow(const avifImage * image, avifRGBImage * rgb, avifReformatState * state)
 {
     // Aliases for some state
     const float kr = state->kr;
@@ -647,7 +647,8 @@
                         }
                     }
 
-                    if (flags & AVIF_CHROMA_UPSAMPLING_NEAREST) {
+                    if ((rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_FASTEST) ||
+                        (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_NEAREST)) {
                         // Nearest neighbor; ignore all UVs but the closest one
                         Cb = unormFloatTableUV[unormU[0][0]];
                         Cr = unormFloatTableUV[unormV[0][0]];
@@ -1163,10 +1164,10 @@
     return AVIF_RESULT_OK;
 }
 
-static avifResult avifRGBImageToF16(avifRGBImage * rgb, avifYUVToRGBFlags flags)
+static avifResult avifRGBImageToF16(avifRGBImage * rgb)
 {
     avifResult libyuvResult = AVIF_RESULT_NOT_IMPLEMENTED;
-    if (!(flags & AVIF_YUV_TO_RGB_AVOID_LIBYUV)) {
+    if (!rgb->avoidLibYUV) {
         libyuvResult = avifRGBImageToF16LibYUV(rgb);
     }
     if (libyuvResult != AVIF_RESULT_NOT_IMPLEMENTED) {
@@ -1195,7 +1196,7 @@
     return AVIF_RESULT_OK;
 }
 
-avifResult avifImageYUVToRGB(const avifImage * image, avifRGBImage * rgb, avifYUVToRGBFlags flags)
+avifResult avifImageYUVToRGB(const avifImage * image, avifRGBImage * rgb)
 {
     if (!image->yuvPlanes[AVIF_CHAN_Y]) {
         return AVIF_RESULT_REFORMAT_FAILED;
@@ -1206,16 +1207,10 @@
         return AVIF_RESULT_REFORMAT_FAILED;
     }
 
-    // At most one filter can be specified.
-    if ((flags & AVIF_CHROMA_UPSAMPLING_NEAREST) && (flags & AVIF_CHROMA_UPSAMPLING_BILINEAR)) {
-        return AVIF_RESULT_REFORMAT_FAILED;
-    }
-
     avifAlphaMultiplyMode alphaMultiplyMode = state.toRGBAlphaMode;
     avifBool convertedWithLibYUV = AVIF_FALSE;
-    if (!(flags & AVIF_YUV_TO_RGB_AVOID_LIBYUV) &&
-        ((alphaMultiplyMode == AVIF_ALPHA_MULTIPLY_MODE_NO_OP) || avifRGBFormatHasAlpha(rgb->format))) {
-        avifResult libyuvResult = avifImageYUVToRGBLibYUV(image, rgb, flags);
+    if (!rgb->avoidLibYUV && ((alphaMultiplyMode == AVIF_ALPHA_MULTIPLY_MODE_NO_OP) || avifRGBFormatHasAlpha(rgb->format))) {
+        avifResult libyuvResult = avifImageYUVToRGBLibYUV(image, rgb);
         if (libyuvResult == AVIF_RESULT_OK) {
             convertedWithLibYUV = AVIF_TRUE;
         } else {
@@ -1263,7 +1258,8 @@
         const avifBool hasColor =
             (image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V] && (image->yuvFormat != AVIF_PIXEL_FORMAT_YUV400));
 
-        if ((!hasColor || (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) || (flags & AVIF_CHROMA_UPSAMPLING_NEAREST)) &&
+        if ((!hasColor || (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) ||
+             ((rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_FASTEST) || (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_NEAREST))) &&
             (alphaMultiplyMode == AVIF_ALPHA_MULTIPLY_MODE_NO_OP || avifRGBFormatHasAlpha(rgb->format))) {
             // Explanations on the above conditional:
             // * None of these fast paths currently support bilinear upsampling, so avoid all of them
@@ -1325,7 +1321,7 @@
 
         if (convertResult == AVIF_RESULT_NOT_IMPLEMENTED) {
             // If we get here, there is no fast path for this combination. Time to be slow!
-            convertResult = avifImageYUVAnyToRGBAnySlow(image, rgb, &state, flags);
+            convertResult = avifImageYUVAnyToRGBAnySlow(image, rgb, &state);
 
             // The slow path also handles alpha (un)multiply, so forget the operation here.
             alphaMultiplyMode = AVIF_ALPHA_MULTIPLY_MODE_NO_OP;
@@ -1351,7 +1347,7 @@
 
     // Convert pixels to half floats (F16), if necessary.
     if (rgb->isFloat) {
-        return avifRGBImageToF16(rgb, flags);
+        return avifRGBImageToF16(rgb);
     }
 
     return AVIF_RESULT_OK;
diff --git a/src/reformat_libyuv.c b/src/reformat_libyuv.c
index 9a9a18d..f4cb5b2 100644
--- a/src/reformat_libyuv.c
+++ b/src/reformat_libyuv.c
@@ -12,11 +12,10 @@
     (void)rgb;
     return AVIF_RESULT_NOT_IMPLEMENTED;
 }
-avifResult avifImageYUVToRGBLibYUV(const avifImage * image, avifRGBImage * rgb, avifYUVToRGBFlags flags)
+avifResult avifImageYUVToRGBLibYUV(const avifImage * image, avifRGBImage * rgb)
 {
     (void)image;
     (void)rgb;
-    (void)flags;
     return AVIF_RESULT_NOT_IMPLEMENTED;
 }
 avifResult avifRGBImagePremultiplyAlphaLibYUV(avifRGBImage * rgb)
@@ -325,15 +324,13 @@
 static avifResult avifImageYUVToRGBLibYUV8bpc(const avifImage * image,
                                               avifRGBImage * rgb,
                                               const struct YuvConstants * matrixYUV,
-                                              const struct YuvConstants * matrixYVU,
-                                              avifYUVToRGBFlags flags);
+                                              const struct YuvConstants * matrixYVU);
 static avifResult avifImageYUVToRGBLibYUVHighBitDepth(const avifImage * image,
                                                       avifRGBImage * rgb,
                                                       const struct YuvConstants * matrixYUV,
-                                                      const struct YuvConstants * matrixYVU,
-                                                      avifYUVToRGBFlags flags);
+                                                      const struct YuvConstants * matrixYVU);
 
-avifResult avifImageYUVToRGBLibYUV(const avifImage * image, avifRGBImage * rgb, avifYUVToRGBFlags flags)
+avifResult avifImageYUVToRGBLibYUV(const avifImage * image, avifRGBImage * rgb)
 {
     // See if the current settings can be accomplished with libyuv, and use it (if possible).
 
@@ -469,11 +466,11 @@
     }
 
     if ((image->depth == 8) && (rgb->depth == 8)) {
-        return avifImageYUVToRGBLibYUV8bpc(image, rgb, matrixYUV, matrixYVU, flags);
+        return avifImageYUVToRGBLibYUV8bpc(image, rgb, matrixYUV, matrixYVU);
     }
 
     if (((image->depth == 10) || (image->depth == 12)) && (rgb->depth == 8)) {
-        return avifImageYUVToRGBLibYUVHighBitDepth(image, rgb, matrixYUV, matrixYVU, flags);
+        return avifImageYUVToRGBLibYUVHighBitDepth(image, rgb, matrixYUV, matrixYVU);
     }
 
     // This function didn't do anything; use the built-in YUV conversion
@@ -497,8 +494,7 @@
 avifResult avifImageYUVToRGBLibYUV8bpc(const avifImage * image,
                                        avifRGBImage * rgb,
                                        const struct YuvConstants * matrixYUV,
-                                       const struct YuvConstants * matrixYVU,
-                                       avifYUVToRGBFlags flags)
+                                       const struct YuvConstants * matrixYVU)
 {
     // See if the current settings can be accomplished with libyuv, and use it (if possible).
 
@@ -575,7 +571,10 @@
         };
         YUVToRGBMatrixFilter yuvToRgbMatrixFilter = lutYuvToRgbMatrixFilter[rgb->format][image->yuvFormat];
         if (yuvToRgbMatrixFilter != NULL) {
-            const enum FilterMode filter = (flags & AVIF_CHROMA_UPSAMPLING_NEAREST) ? kFilterNone : kFilterBilinear;
+            const enum FilterMode filter = ((rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_FASTEST) ||
+                                            (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_NEAREST))
+                                               ? kFilterNone
+                                               : kFilterBilinear;
             if (yuvToRgbMatrixFilter(image->yuvPlanes[AVIF_CHAN_Y],
                                      image->yuvRowBytes[AVIF_CHAN_Y],
                                      image->yuvPlanes[uPlaneIndex],
@@ -594,7 +593,7 @@
         }
 
         // Only proceed with the nearest-neighbor filter if explicitly specified or left as default.
-        if (flags & AVIF_CHROMA_UPSAMPLING_BILINEAR) {
+        if ((rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_BEST_QUALITY) || (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_BILINEAR)) {
             return AVIF_RESULT_NOT_IMPLEMENTED;
         }
         // Lookup table for YUV To RGB Matrix (nearest-neighbor filter).
@@ -636,8 +635,7 @@
 avifResult avifImageYUVToRGBLibYUVHighBitDepth(const avifImage * image,
                                                avifRGBImage * rgb,
                                                const struct YuvConstants * matrixYUV,
-                                               const struct YuvConstants * matrixYVU,
-                                               avifYUVToRGBFlags flags)
+                                               const struct YuvConstants * matrixYVU)
 {
     // See if the current settings can be accomplished with libyuv, and use it (if possible).
 
@@ -704,7 +702,10 @@
     };
     YUVToRGBMatrixFilter yuvToRgbMatrixFilter = lutYuvToRgbMatrixFilter[depthIndex][rgb->format][image->yuvFormat];
     if (yuvToRgbMatrixFilter != NULL) {
-        const enum FilterMode filter = (flags & AVIF_CHROMA_UPSAMPLING_NEAREST) ? kFilterNone : kFilterBilinear;
+        const enum FilterMode filter =
+            ((rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_FASTEST) || (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_NEAREST))
+                ? kFilterNone
+                : kFilterBilinear;
         if (yuvToRgbMatrixFilter((const uint16_t *)image->yuvPlanes[AVIF_CHAN_Y],
                                  image->yuvRowBytes[AVIF_CHAN_Y] / 2,
                                  (const uint16_t *)image->yuvPlanes[uPlaneIndex],
@@ -723,7 +724,7 @@
     }
 
     // Only proceed with the nearest-neighbor filter if explicitly specified or left as default.
-    if (flags & AVIF_CHROMA_UPSAMPLING_BILINEAR) {
+    if ((rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_BEST_QUALITY) || (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_BILINEAR)) {
         return AVIF_RESULT_NOT_IMPLEMENTED;
     }
     // Lookup table for YUV To RGB Matrix (nearest-neighbor filter).
diff --git a/tests/avifyuv.c b/tests/avifyuv.c
index a98dad7..b7e2df1 100644
--- a/tests/avifyuv.c
+++ b/tests/avifyuv.c
@@ -203,8 +203,8 @@
                                 }
                             }
 
-                            avifImageRGBToYUV(image, &srcRGB, AVIF_RGB_TO_YUV_DEFAULT);
-                            avifImageYUVToRGB(image, &dstRGB, AVIF_YUV_TO_RGB_DEFAULT);
+                            avifImageRGBToYUV(image, &srcRGB);
+                            avifImageYUVToRGB(image, &dstRGB);
 
                             for (int y = 0; y < dim; ++y) {
                                 const uint8_t * srcRow = &srcRGB.pixels[y * srcRGB.rowBytes];
@@ -344,23 +344,23 @@
                         avifImageFreePlanes(image, AVIF_PLANES_ALL);
                         image->depth = yuvDepth;
                         image->yuvRange = yuvRange;
-                        avifImageRGBToYUV(image, &srcRGB, AVIF_RGB_TO_YUV_DEFAULT);
+                        avifImageRGBToYUV(image, &srcRGB);
 
                         avifRGBImage intermediateRGB;
                         avifRGBImageSetDefaults(&intermediateRGB, image);
                         intermediateRGB.depth = rgbDepth;
                         intermediateRGB.format = rgbFormat;
                         avifRGBImageAllocatePixels(&intermediateRGB);
-                        avifImageYUVToRGB(image, &intermediateRGB, AVIF_YUV_TO_RGB_DEFAULT);
+                        avifImageYUVToRGB(image, &intermediateRGB);
 
                         avifImageFreePlanes(image, AVIF_PLANES_ALL);
-                        avifImageRGBToYUV(image, &intermediateRGB, AVIF_RGB_TO_YUV_DEFAULT);
+                        avifImageRGBToYUV(image, &intermediateRGB);
 
                         avifRGBImage dstRGB;
                         avifRGBImageSetDefaults(&dstRGB, image);
                         dstRGB.depth = yuvDepth;
                         avifRGBImageAllocatePixels(&dstRGB);
-                        avifImageYUVToRGB(image, &dstRGB, AVIF_YUV_TO_RGB_DEFAULT);
+                        avifImageYUVToRGB(image, &dstRGB);
 
                         avifBool moveOn = AVIF_FALSE;
                         for (uint32_t j = 0; j < originalHeight; ++j) {
diff --git a/tests/gtest/are_images_equal.cc b/tests/gtest/are_images_equal.cc
index ac9c1d2..93a1012 100644
--- a/tests/gtest/are_images_equal.cc
+++ b/tests/gtest/are_images_equal.cc
@@ -31,10 +31,10 @@
     // Make sure no color conversion happens.
     decoded[i]->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_IDENTITY;
     if (avifReadImage(argv[i + 1], requestedFormat, kRequestedDepth,
-                      AVIF_RGB_TO_YUV_DEFAULT, /*ignoreICC=*/AVIF_FALSE,
-                      /*ignoreExif=*/AVIF_FALSE, /*ignoreXMP=*/AVIF_FALSE,
-                      decoded[i].get(), &depth[i], nullptr,
-                      nullptr) == AVIF_APP_FILE_FORMAT_UNKNOWN) {
+                      AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC,
+                      /*ignoreICC=*/AVIF_FALSE, /*ignoreExif=*/AVIF_FALSE,
+                      /*ignoreXMP=*/AVIF_FALSE, decoded[i].get(), &depth[i],
+                      nullptr, nullptr) == AVIF_APP_FILE_FORMAT_UNKNOWN) {
       std::cerr << "Image " << argv[i + 1] << " cannot be read." << std::endl;
       return 2;
     }
diff --git a/tests/gtest/avifmetadatatest.cc b/tests/gtest/avifmetadatatest.cc
index 4ac7961..5017f13 100644
--- a/tests/gtest/avifmetadatatest.cc
+++ b/tests/gtest/avifmetadatatest.cc
@@ -121,8 +121,8 @@
   const bool expect_xmp = std::get<6>(GetParam());
 
   const testutil::AvifImagePtr image = testutil::ReadImage(
-      data_path, file_name, AVIF_PIXEL_FORMAT_NONE, 0, AVIF_RGB_TO_YUV_DEFAULT,
-      !use_icc, !use_exif, !use_xmp);
+      data_path, file_name, AVIF_PIXEL_FORMAT_NONE, 0,
+      AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC, !use_icc, !use_exif, !use_xmp);
   ASSERT_NE(image, nullptr);
   EXPECT_NE(image->width * image->height, 0u);
 
diff --git a/tests/gtest/avifrgbtoyuvtest.cc b/tests/gtest/avifrgbtoyuvtest.cc
index 08e417e..81b5675 100644
--- a/tests/gtest/avifrgbtoyuvtest.cc
+++ b/tests/gtest/avifrgbtoyuvtest.cc
@@ -112,12 +112,11 @@
 //------------------------------------------------------------------------------
 
 class RGBToYUVTest
-    : public testing::TestWithParam<
-          std::tuple</*rgb_depth=*/int, /*yuv_depth=*/int, avifRGBFormat,
-                     avifPixelFormat, avifRange, avifMatrixCoefficients,
-                     /*sharpYuv=*/bool,
-                     /*add_noise=*/bool, /*rgb_step=*/uint32_t,
-                     /*max_abs_average_diff=*/double, /*min_psnr=*/double>> {};
+    : public testing::TestWithParam<std::tuple<
+          /*rgb_depth=*/int, /*yuv_depth=*/int, avifRGBFormat, avifPixelFormat,
+          avifRange, avifMatrixCoefficients, avifChromaDownsampling,
+          /*add_noise=*/bool, /*rgb_step=*/uint32_t,
+          /*max_abs_average_diff=*/double, /*min_psnr=*/double>> {};
 
 // Converts from RGB to YUV and back to RGB for all RGB combinations, separated
 // by a color step for reasonable timing. If add_noise is true, also applies
@@ -129,7 +128,7 @@
   const avifPixelFormat yuv_format = std::get<3>(GetParam());
   const avifRange yuv_range = std::get<4>(GetParam());
   const avifMatrixCoefficients matrix_coefficients = std::get<5>(GetParam());
-  const avifRGBToYUVFlags rgb_to_yuv_flags = std::get<6>(GetParam());
+  const avifChromaDownsampling chroma_downsampling = std::get<6>(GetParam());
   // Whether to add noise to the input RGB samples. Should only impact
   // subsampled chroma (4:2:2 and 4:2:0).
   const bool add_noise = std::get<7>(GetParam());
@@ -154,6 +153,7 @@
   yuv->matrixCoefficients = matrix_coefficients;
   yuv->yuvRange = yuv_range;
   testutil::AvifRgbImage src_rgb(yuv.get(), rgb_depth, rgb_format);
+  src_rgb.chromaDownsampling = chroma_downsampling;
   testutil::AvifRgbImage dst_rgb(yuv.get(), rgb_depth, rgb_format);
   const testutil::RgbChannelOffsets offsets =
       testutil::GetRgbChannelOffsets(rgb_format);
@@ -184,10 +184,8 @@
         ModifyImageChannel(&src_rgb, offsets.b, kBlueNoise);
       }
 
-      ASSERT_EQ(avifImageRGBToYUV(yuv.get(), &src_rgb, rgb_to_yuv_flags),
-                AVIF_RESULT_OK);
-      ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &dst_rgb, AVIF_YUV_TO_RGB_DEFAULT),
-                AVIF_RESULT_OK);
+      ASSERT_EQ(avifImageRGBToYUV(yuv.get(), &src_rgb), AVIF_RESULT_OK);
+      ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &dst_rgb), AVIF_RESULT_OK);
       GetDiffSumAndSqDiffSum(src_rgb, dst_rgb, &diff_sum, &abs_diff_sum,
                              &sq_diff_sum, &max_abs_diff);
       num_diffs += src_rgb.width * src_rgb.height * 3;  // Alpha is lossless.
@@ -205,12 +203,8 @@
             ModifyImageChannel(&src_rgb, offsets.b, kBlueNoise);
           }
 
-          ASSERT_EQ(
-              avifImageRGBToYUV(yuv.get(), &src_rgb, AVIF_RGB_TO_YUV_DEFAULT),
-              AVIF_RESULT_OK);
-          ASSERT_EQ(
-              avifImageYUVToRGB(yuv.get(), &dst_rgb, AVIF_YUV_TO_RGB_DEFAULT),
-              AVIF_RESULT_OK);
+          ASSERT_EQ(avifImageRGBToYUV(yuv.get(), &src_rgb), AVIF_RESULT_OK);
+          ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &dst_rgb), AVIF_RESULT_OK);
           GetDiffSumAndSqDiffSum(src_rgb, dst_rgb, &diff_sum, &abs_diff_sum,
                                  &sq_diff_sum, &max_abs_diff);
           num_diffs +=
@@ -254,8 +248,9 @@
   const avifPixelFormat yuv_format = std::get<3>(GetParam());
   const avifRange yuv_range = std::get<4>(GetParam());
   const avifMatrixCoefficients matrix_coefficients = std::get<5>(GetParam());
+  const avifChromaDownsampling chroma_downsampling = std::get<6>(GetParam());
   // Whether to add noise to the input RGB samples.
-  const bool add_noise = std::get<6>(GetParam());
+  const bool add_noise = std::get<7>(GetParam());
   // Threshold to pass.
   const double min_psnr = std::get<9>(GetParam());
   // Deduced constants.
@@ -274,6 +269,7 @@
       yuv->matrixCoefficients = matrix_coefficients;
       yuv->yuvRange = yuv_range;
       testutil::AvifRgbImage src_rgb(yuv.get(), rgb_depth, rgb_format);
+      src_rgb.chromaDownsampling = chroma_downsampling;
       testutil::AvifRgbImage dst_rgb(yuv.get(), rgb_depth, rgb_format);
       const testutil::RgbChannelOffsets offsets =
           testutil::GetRgbChannelOffsets(rgb_format);
@@ -294,10 +290,8 @@
         testutil::FillImageChannel(&src_rgb, offsets.a, rgb_max);
       }
 
-      ASSERT_EQ(avifImageRGBToYUV(yuv.get(), &src_rgb, AVIF_RGB_TO_YUV_DEFAULT),
-                AVIF_RESULT_OK);
-      ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &dst_rgb, AVIF_YUV_TO_RGB_DEFAULT),
-                AVIF_RESULT_OK);
+      ASSERT_EQ(avifImageRGBToYUV(yuv.get(), &src_rgb), AVIF_RESULT_OK);
+      ASSERT_EQ(avifImageYUVToRGB(yuv.get(), &dst_rgb), AVIF_RESULT_OK);
       GetDiffSumAndSqDiffSum(src_rgb, dst_rgb, &diff_sum, &abs_diff_sum,
                              &sq_diff_sum, &max_abs_diff);
       num_diffs += src_rgb.width * src_rgb.height * 3;
@@ -330,7 +324,7 @@
             /*yuv_depth=*/Values(8), Values(AVIF_RGB_FORMAT_RGBA),
             Values(AVIF_PIXEL_FORMAT_YUV420), Values(AVIF_RANGE_FULL),
             Values(kMatrixCoefficientsBT601),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
+            Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
             /*add_noise=*/Values(true),
             /*rgb_step=*/Values(3),
             /*max_abs_average_diff=*/Values(0.1),  // The color drift is almost
@@ -340,39 +334,42 @@
 
 // Keeping RGB samples in full range and same or higher bit depth should not
 // bring any loss in the roundtrip.
-INSTANTIATE_TEST_SUITE_P(
-    Identity8b, RGBToYUVTest,
-    Combine(/*rgb_depth=*/Values(8),
-            /*yuv_depth=*/Values(8, 10, 12), ValuesIn(kAllRgbFormats),
-            Values(AVIF_PIXEL_FORMAT_YUV444), Values(AVIF_RANGE_FULL),
-            Values(kMatrixCoefficientsIdentity),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
-            /*add_noise=*/Values(true),
-            /*rgb_step=*/Values(31),
-            /*max_abs_average_diff=*/Values(0.),
-            /*min_psnr=*/Values(99.)));
-INSTANTIATE_TEST_SUITE_P(
-    Identity10b, RGBToYUVTest,
-    Combine(/*rgb_depth=*/Values(10),
-            /*yuv_depth=*/Values(10, 12), ValuesIn(kAllRgbFormats),
-            Values(AVIF_PIXEL_FORMAT_YUV444), Values(AVIF_RANGE_FULL),
-            Values(kMatrixCoefficientsIdentity),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
-            /*add_noise=*/Values(true),
-            /*rgb_step=*/Values(101),
-            /*max_abs_average_diff=*/Values(0.),
-            /*min_psnr=*/Values(99.)));
-INSTANTIATE_TEST_SUITE_P(
-    Identity12b, RGBToYUVTest,
-    Combine(/*rgb_depth=*/Values(12),
-            /*yuv_depth=*/Values(12), ValuesIn(kAllRgbFormats),
-            Values(AVIF_PIXEL_FORMAT_YUV444), Values(AVIF_RANGE_FULL),
-            Values(kMatrixCoefficientsIdentity),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
-            /*add_noise=*/Values(true),
-            /*rgb_step=*/Values(401),
-            /*max_abs_average_diff=*/Values(0.),
-            /*min_psnr=*/Values(99.)));
+INSTANTIATE_TEST_SUITE_P(Identity8b, RGBToYUVTest,
+                         Combine(/*rgb_depth=*/Values(8),
+                                 /*yuv_depth=*/Values(8, 10, 12),
+                                 ValuesIn(kAllRgbFormats),
+                                 Values(AVIF_PIXEL_FORMAT_YUV444),
+                                 Values(AVIF_RANGE_FULL),
+                                 Values(kMatrixCoefficientsIdentity),
+                                 Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
+                                 /*add_noise=*/Values(true),
+                                 /*rgb_step=*/Values(31),
+                                 /*max_abs_average_diff=*/Values(0.),
+                                 /*min_psnr=*/Values(99.)));
+INSTANTIATE_TEST_SUITE_P(Identity10b, RGBToYUVTest,
+                         Combine(/*rgb_depth=*/Values(10),
+                                 /*yuv_depth=*/Values(10, 12),
+                                 ValuesIn(kAllRgbFormats),
+                                 Values(AVIF_PIXEL_FORMAT_YUV444),
+                                 Values(AVIF_RANGE_FULL),
+                                 Values(kMatrixCoefficientsIdentity),
+                                 Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
+                                 /*add_noise=*/Values(true),
+                                 /*rgb_step=*/Values(101),
+                                 /*max_abs_average_diff=*/Values(0.),
+                                 /*min_psnr=*/Values(99.)));
+INSTANTIATE_TEST_SUITE_P(Identity12b, RGBToYUVTest,
+                         Combine(/*rgb_depth=*/Values(12),
+                                 /*yuv_depth=*/Values(12),
+                                 ValuesIn(kAllRgbFormats),
+                                 Values(AVIF_PIXEL_FORMAT_YUV444),
+                                 Values(AVIF_RANGE_FULL),
+                                 Values(kMatrixCoefficientsIdentity),
+                                 Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
+                                 /*add_noise=*/Values(true),
+                                 /*rgb_step=*/Values(401),
+                                 /*max_abs_average_diff=*/Values(0.),
+                                 /*min_psnr=*/Values(99.)));
 
 // 4:4:4 and chroma subsampling have similar distortions on plain color inputs.
 INSTANTIATE_TEST_SUITE_P(
@@ -383,7 +380,7 @@
         Values(AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
                AVIF_PIXEL_FORMAT_YUV420),
         Values(AVIF_RANGE_FULL), Values(kMatrixCoefficientsBT601),
-        /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
+        Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
         /*add_noise=*/Values(false),
         /*rgb_step=*/Values(17),
         /*max_abs_average_diff=*/Values(0.02),  // The color drift is centered.
@@ -393,39 +390,42 @@
 
 // Converting grey RGB samples to full-range monochrome of same or greater bit
 // depth should be lossless.
-INSTANTIATE_TEST_SUITE_P(
-    MonochromeLossless8b, RGBToYUVTest,
-    Combine(/*rgb_depth=*/Values(8),
-            /*yuv_depth=*/Values(8, 10, 12), ValuesIn(kAllRgbFormats),
-            Values(AVIF_PIXEL_FORMAT_YUV400), Values(AVIF_RANGE_FULL),
-            Values(kMatrixCoefficientsBT601),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
-            /*add_noise=*/Values(false),
-            /*rgb_step=*/Values(1),
-            /*max_abs_average_diff=*/Values(0.),
-            /*min_psnr=*/Values(99.)));
-INSTANTIATE_TEST_SUITE_P(
-    MonochromeLossless10b, RGBToYUVTest,
-    Combine(/*rgb_depth=*/Values(10),
-            /*yuv_depth=*/Values(10, 12), ValuesIn(kAllRgbFormats),
-            Values(AVIF_PIXEL_FORMAT_YUV400), Values(AVIF_RANGE_FULL),
-            Values(kMatrixCoefficientsBT601),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
-            /*add_noise=*/Values(false),
-            /*rgb_step=*/Values(1),
-            /*max_abs_average_diff=*/Values(0.),
-            /*min_psnr=*/Values(99.)));
-INSTANTIATE_TEST_SUITE_P(
-    MonochromeLossless12b, RGBToYUVTest,
-    Combine(/*rgb_depth=*/Values(12),
-            /*yuv_depth=*/Values(12), ValuesIn(kAllRgbFormats),
-            Values(AVIF_PIXEL_FORMAT_YUV400), Values(AVIF_RANGE_FULL),
-            Values(kMatrixCoefficientsBT601),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
-            /*add_noise=*/Values(false),
-            /*rgb_step=*/Values(1),
-            /*max_abs_average_diff=*/Values(0.),
-            /*min_psnr=*/Values(99.)));
+INSTANTIATE_TEST_SUITE_P(MonochromeLossless8b, RGBToYUVTest,
+                         Combine(/*rgb_depth=*/Values(8),
+                                 /*yuv_depth=*/Values(8, 10, 12),
+                                 ValuesIn(kAllRgbFormats),
+                                 Values(AVIF_PIXEL_FORMAT_YUV400),
+                                 Values(AVIF_RANGE_FULL),
+                                 Values(kMatrixCoefficientsBT601),
+                                 Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
+                                 /*add_noise=*/Values(false),
+                                 /*rgb_step=*/Values(1),
+                                 /*max_abs_average_diff=*/Values(0.),
+                                 /*min_psnr=*/Values(99.)));
+INSTANTIATE_TEST_SUITE_P(MonochromeLossless10b, RGBToYUVTest,
+                         Combine(/*rgb_depth=*/Values(10),
+                                 /*yuv_depth=*/Values(10, 12),
+                                 ValuesIn(kAllRgbFormats),
+                                 Values(AVIF_PIXEL_FORMAT_YUV400),
+                                 Values(AVIF_RANGE_FULL),
+                                 Values(kMatrixCoefficientsBT601),
+                                 Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
+                                 /*add_noise=*/Values(false),
+                                 /*rgb_step=*/Values(1),
+                                 /*max_abs_average_diff=*/Values(0.),
+                                 /*min_psnr=*/Values(99.)));
+INSTANTIATE_TEST_SUITE_P(MonochromeLossless12b, RGBToYUVTest,
+                         Combine(/*rgb_depth=*/Values(12),
+                                 /*yuv_depth=*/Values(12),
+                                 ValuesIn(kAllRgbFormats),
+                                 Values(AVIF_PIXEL_FORMAT_YUV400),
+                                 Values(AVIF_RANGE_FULL),
+                                 Values(kMatrixCoefficientsBT601),
+                                 Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
+                                 /*add_noise=*/Values(false),
+                                 /*rgb_step=*/Values(1),
+                                 /*max_abs_average_diff=*/Values(0.),
+                                 /*min_psnr=*/Values(99.)));
 
 // Can be used to print the drift of all RGB to YUV conversion possibilities.
 // Also used for coverage.
@@ -437,7 +437,7 @@
         Values(AVIF_PIXEL_FORMAT_YUV420),
         Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
         Values(kMatrixCoefficientsBT601, kMatrixCoefficientsBT709),
-        /*avif_rgb_to_yuv_flags=*/Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
+        Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
         /*add_noise=*/Values(true),
         /*rgb_step=*/Values(17),
         /*max_abs_average_diff=*/Values(1.2),  // Sharp YUV introduces some
@@ -452,7 +452,7 @@
         Values(AVIF_PIXEL_FORMAT_YUV420),
         Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
         Values(kMatrixCoefficientsBT601),
-        /*avif_rgb_to_yuv_flags=*/Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
+        Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
         /*add_noise=*/Values(true),
         /*rgb_step=*/Values(211),              // High or it would be too slow.
         /*max_abs_average_diff=*/Values(1.2),  // Sharp YUV introduces some
@@ -467,7 +467,7 @@
         Values(AVIF_PIXEL_FORMAT_YUV420),
         Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
         Values(kMatrixCoefficientsBT601),
-        /*avif_rgb_to_yuv_flags=*/Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
+        Values(AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV),
         /*add_noise=*/Values(true),
         /*rgb_step=*/Values(840),              // High or it would be too slow.
         /*max_abs_average_diff=*/Values(1.2),  // Sharp YUV introduces some
@@ -485,7 +485,7 @@
                    AVIF_PIXEL_FORMAT_YUV420),
             Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
             Values(kMatrixCoefficientsBT601),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
+            Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
             /*add_noise=*/Values(false, true),
             /*rgb_step=*/Values(61),  // High or it would be too slow.
             /*max_abs_average_diff=*/Values(1.),  // Not very accurate because
@@ -499,7 +499,7 @@
                    AVIF_PIXEL_FORMAT_YUV420),
             Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
             Values(kMatrixCoefficientsBT601),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
+            Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
             /*add_noise=*/Values(false, true),
             /*rgb_step=*/Values(211),  // High or it would be too slow.
             /*max_abs_average_diff=*/Values(0.2),  // Not very accurate because
@@ -513,7 +513,7 @@
                    AVIF_PIXEL_FORMAT_YUV420),
             Values(AVIF_RANGE_LIMITED, AVIF_RANGE_FULL),
             Values(kMatrixCoefficientsBT601),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
+            Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
             /*add_noise=*/Values(false, true),
             /*rgb_step=*/Values(809),  // High or it would be too slow.
             /*max_abs_average_diff=*/Values(0.3),  // Not very accurate because
@@ -532,7 +532,7 @@
                    AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400),
             Values(AVIF_RANGE_FULL, AVIF_RANGE_LIMITED),
             Values(kMatrixCoefficientsBT601),
-            /*avif_rgb_to_yuv_flags=*/Values(AVIF_RGB_TO_YUV_DEFAULT),
+            Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
             /*add_noise=*/Values(false, true),
             /*rgb_step=*/Values(3),  // way faster and 99% similar to rgb_step=1
             /*max_abs_average_diff=*/Values(10.),
diff --git a/tests/gtest/aviftest_helpers.cc b/tests/gtest/aviftest_helpers.cc
index 25827b6..57d8929 100644
--- a/tests/gtest/aviftest_helpers.cc
+++ b/tests/gtest/aviftest_helpers.cc
@@ -233,7 +233,7 @@
 
 AvifImagePtr ReadImage(const char* folder_path, const char* file_name,
                        avifPixelFormat requested_format, int requested_depth,
-                       avifRGBToYUVFlags flags, avifBool ignore_icc,
+                       avifChromaDownsampling flags, avifBool ignore_icc,
                        avifBool ignore_exif, avifBool ignore_xmp) {
   testutil::AvifImagePtr image(avifImageCreateEmpty(), avifImageDestroy);
   if (!image ||
diff --git a/tests/gtest/aviftest_helpers.h b/tests/gtest/aviftest_helpers.h
index 842b60d..a0b1c05 100644
--- a/tests/gtest/aviftest_helpers.h
+++ b/tests/gtest/aviftest_helpers.h
@@ -75,7 +75,8 @@
 AvifImagePtr ReadImage(
     const char* folder_path, const char* file_name,
     avifPixelFormat requested_format = AVIF_PIXEL_FORMAT_NONE,
-    int requested_depth = 0, avifRGBToYUVFlags flags = AVIF_RGB_TO_YUV_DEFAULT,
+    int requested_depth = 0,
+    avifChromaDownsampling flags = AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC,
     avifBool ignore_icc = false, avifBool ignore_exif = false,
     avifBool ignore_xmp = false);
 
diff --git a/tests/oss-fuzz/avif_decode_fuzzer.cc b/tests/oss-fuzz/avif_decode_fuzzer.cc
index 702185c..ba3f924 100644
--- a/tests/oss-fuzz/avif_decode_fuzzer.cc
+++ b/tests/oss-fuzz/avif_decode_fuzzer.cc
@@ -8,7 +8,7 @@
     static avifRGBFormat rgbFormats[] = { AVIF_RGB_FORMAT_RGB, AVIF_RGB_FORMAT_RGBA };
     static size_t rgbFormatsCount = sizeof(rgbFormats) / sizeof(rgbFormats[0]);
 
-    static avifYUVToRGBFlags upsamplingFlags[] = { AVIF_CHROMA_UPSAMPLING_BILINEAR, AVIF_CHROMA_UPSAMPLING_NEAREST };
+    static avifChromaUpsampling upsamplingFlags[] = { AVIF_CHROMA_UPSAMPLING_BILINEAR, AVIF_CHROMA_UPSAMPLING_NEAREST };
     static size_t upsamplingFlagsCount = sizeof(upsamplingFlags) / sizeof(upsamplingFlags[0]);
 
     static uint32_t rgbDepths[] = { 8, 10 };
@@ -47,10 +47,11 @@
                         for (size_t rgbDepthsIndex = 0; rgbDepthsIndex < rgbDepthsCount; ++rgbDepthsIndex) {
                             // Convert to RGB
                             rgb.format = rgbFormats[rgbFormatsIndex];
+                            rgb.chromaUpsampling = upsamplingFlags[upsamplingFlagsIndex];
+                            rgb.avoidLibYUV = AVIF_TRUE;
                             rgb.depth = rgbDepths[rgbDepthsIndex];
                             avifRGBImageAllocatePixels(&rgb);
-                            avifResult rgbResult =
-                                avifImageYUVToRGB(decoder->image, &rgb, AVIF_YUV_TO_RGB_AVOID_LIBYUV | upsamplingFlags[upsamplingFlagsIndex]);
+                            avifResult rgbResult = avifImageYUVToRGB(decoder->image, &rgb);
                             // Since avifImageRGBToYUV() ignores upsamplingFlags, we only need
                             // to test avifImageRGBToYUV() with a single upsamplingFlagsIndex.
                             if ((rgbResult == AVIF_RESULT_OK) && (upsamplingFlagsIndex == 0)) {
@@ -60,7 +61,7 @@
                                                                             decoder->image->height,
                                                                             yuvDepths[yuvDepthsIndex],
                                                                             decoder->image->yuvFormat);
-                                    avifResult yuvResult = avifImageRGBToYUV(tempImage, &rgb, AVIF_RGB_TO_YUV_AVOID_LIBYUV);
+                                    avifResult yuvResult = avifImageRGBToYUV(tempImage, &rgb);
                                     if (yuvResult != AVIF_RESULT_OK) {
                                     }
                                     avifImageDestroy(tempImage);