Allow YCgCoRe and YCgCoRo decoding.

Now that the https://www.itu.int/rec/T-REC-H.273 update is to be
published, we can allow for decoding by default.
Encoding will come once decoding is sufficiently deployed.

This is the first phase of
#2077

CHANGELOG.md

@@ -91,6 +91,8 @@ The changes are relative to the previous release, unless the baseline is specifi
   (https://crbug.com/oss-fuzz/65657).
 * ext/libjpeg.cmd now pulls libjpeg-turbo instead of libjpeg and AVIF_JPEG=LOCAL
   now expects the library dependency in ext/libjpeg-turbo/build.libavif.
+* Allow YCgCo_Re and YCgCo_Ro decoding by default. Encoding is still conditioned
+  to the AVIF_ENABLE_EXPERIMENTAL_YCGCO CMake flag.
 
 ## [1.0.4] - 2024-02-08
 

CMakeLists.txt

@@ -37,7 +37,7 @@ option(BUILD_SHARED_LIBS "Build shared avif library" ON)
 option(AVIF_ENABLE_WERROR "Treat all compiler warnings as errors" OFF)
 option(AVIF_ENABLE_WUNUSED_RESULT "Add [[nodiscard]] to some functions. CMake must be at least 3.21 to force C23" OFF)
 
-option(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R "Enable experimental YCgCo-R matrix code" OFF)
+option(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R "Enable experimental YCgCo-R matrix code for encoding" OFF)
 option(AVIF_ENABLE_EXPERIMENTAL_GAIN_MAP
        "Enable experimental gain map code (for HDR images that look good both on HDR and SDR displays)" OFF
 )

apps/shared/avifjpeg.c

@@ -937,20 +937,15 @@ static avifBool avifJPEGReadInternal(FILE * f,
 
         avif->width = cinfo.output_width;
         avif->height = cinfo.output_height;
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
         const avifBool useYCgCoR = (avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE ||
                                     avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO);
-#else
-        const avifBool useYCgCoR = AVIF_FALSE;
-#endif
         if (avif->yuvFormat == AVIF_PIXEL_FORMAT_NONE) {
             // Identity and YCgCo-R are only valid with YUV444.
             avif->yuvFormat = (avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY || useYCgCoR)
                                   ? AVIF_PIXEL_FORMAT_YUV444
                                   : AVIF_APP_DEFAULT_PIXEL_FORMAT;
         }
         avif->depth = requestedDepth ? requestedDepth : 8;
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
         if (useYCgCoR) {
             if (avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO) {
                 fprintf(stderr, "AVIF_MATRIX_COEFFICIENTS_YCGCO_RO cannot be used with JPEG because it has an even bit depth.\n");
@@ -962,7 +957,6 @@ static avifBool avifJPEGReadInternal(FILE * f,
             }
             avif->depth = 10;
         }
-#endif
         avifRGBImageSetDefaults(&rgb, avif);
         rgb.format = AVIF_RGB_FORMAT_RGB;
         rgb.chromaDownsampling = chromaDownsampling;

apps/shared/avifpng.c

@@ -317,15 +317,11 @@ avifBool avifPNGRead(const char * inputFilename,
     avif->width = rawWidth;
     avif->height = rawHeight;
     avif->yuvFormat = requestedFormat;
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
     if (avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO) {
         fprintf(stderr, "AVIF_MATRIX_COEFFICIENTS_YCGCO_RO cannot be used with PNG because it has an even bit depth.\n");
         goto cleanup;
     }
     const avifBool useYCgCoR = (avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE);
-#else
-    const avifBool useYCgCoR = AVIF_FALSE;
-#endif
     if (avif->yuvFormat == AVIF_PIXEL_FORMAT_NONE) {
         if ((rawColorType == PNG_COLOR_TYPE_GRAY) || (rawColorType == PNG_COLOR_TYPE_GRAY_ALPHA)) {
             avif->yuvFormat = AVIF_PIXEL_FORMAT_YUV400;
@@ -344,7 +340,6 @@ avifBool avifPNGRead(const char * inputFilename,
             avif->depth = 12;
         }
     }
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
     if (useYCgCoR) {
         if (imgBitDepth != 8) {
             fprintf(stderr, "AVIF_MATRIX_COEFFICIENTS_YCGCO_RE cannot be used on 16 bit input because it adds two bits.\n");
@@ -356,7 +351,6 @@ avifBool avifPNGRead(const char * inputFilename,
         }
         avif->depth = 10;
     }
-#endif
 
     if (!ignoreColorProfile) {
         char * iccpProfileName = NULL;
@@ -537,7 +531,6 @@ avifBool avifPNGWrite(const char * outputFilename, const avifImage * avif, uint3
     if (rgbDepth == 0) {
         rgbDepth = (avif->depth > 8) ? 16 : 8;
     }
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
     if (avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO) {
         fprintf(stderr, "AVIF_MATRIX_COEFFICIENTS_YCGCO_RO cannot be used with PNG because it has an even bit depth.\n");
         goto cleanup;
@@ -554,7 +547,6 @@ avifBool avifPNGWrite(const char * outputFilename, const avifImage * avif, uint3
 
         rgbDepth = 8;
     }
-#endif
 
     volatile avifBool monochrome8bit = (avif->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) && !avif->alphaPlane && (avif->depth == 8) &&
                                        (rgbDepth == 8);

include/avif/avif.h

@@ -383,10 +383,8 @@ enum
     AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL = 12,
     AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_CL = 13,
     AVIF_MATRIX_COEFFICIENTS_ICTCP = 14,
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
     AVIF_MATRIX_COEFFICIENTS_YCGCO_RE = 15,
     AVIF_MATRIX_COEFFICIENTS_YCGCO_RO = 16,
-#endif
     AVIF_MATRIX_COEFFICIENTS_LAST
 };
 typedef uint16_t avifMatrixCoefficients; // AVIF_MATRIX_COEFFICIENTS_*

include/avif/internal.h

@@ -186,10 +186,8 @@ typedef enum avifReformatMode
     AVIF_REFORMAT_MODE_YUV_COEFFICIENTS = 0, // Normal YUV conversion using coefficients
     AVIF_REFORMAT_MODE_IDENTITY,             // Pack GBR directly into YUV planes (AVIF_MATRIX_COEFFICIENTS_IDENTITY)
     AVIF_REFORMAT_MODE_YCGCO,                // YUV conversion using AVIF_MATRIX_COEFFICIENTS_YCGCO
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
-    AVIF_REFORMAT_MODE_YCGCO_RE, // YUV conversion using AVIF_MATRIX_COEFFICIENTS_YCGCO_RE
-    AVIF_REFORMAT_MODE_YCGCO_RO, // YUV conversion using AVIF_MATRIX_COEFFICIENTS_YCGCO_RO
-#endif
+    AVIF_REFORMAT_MODE_YCGCO_RE,             // YUV conversion using AVIF_MATRIX_COEFFICIENTS_YCGCO_RE
+    AVIF_REFORMAT_MODE_YCGCO_RO,             // YUV conversion using AVIF_MATRIX_COEFFICIENTS_YCGCO_RO
 } avifReformatMode;
 
 typedef enum avifAlphaMultiplyMode

src/reformat.c

@@ -96,12 +96,8 @@ avifBool avifGetRGBColorSpaceInfo(const avifRGBImage * rgb, avifRGBColorSpaceInf
 
 avifBool avifGetYUVColorSpaceInfo(const avifImage * image, avifYUVColorSpaceInfo * info)
 {
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
     const avifBool useYCgCo = (image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE) ||
                               (image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO);
-#else
-    const avifBool useYCgCo = AVIF_FALSE;
-#endif
 
     AVIF_CHECK(image->depth == 8 || image->depth == 10 || image->depth == 12 || image->depth == 16);
     AVIF_CHECK(image->yuvFormat >= AVIF_PIXEL_FORMAT_YUV444 && image->yuvFormat < AVIF_PIXEL_FORMAT_COUNT);
@@ -143,13 +139,8 @@ avifBool avifGetYUVColorSpaceInfo(const avifImage * image, avifYUVColorSpaceInfo
 
 static avifBool avifPrepareReformatState(const avifImage * image, const avifRGBImage * rgb, avifReformatState * state)
 {
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
     const avifBool useYCgCoRe = (image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE);
     const avifBool useYCgCoRo = (image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO);
-#else
-    const avifBool useYCgCoRe = AVIF_FALSE;
-    const avifBool useYCgCoRo = AVIF_FALSE;
-#endif
     if (useYCgCoRe || useYCgCoRo) {
         const int bitOffset = (useYCgCoRe) ? 2 : 1;
         if (image->depth - bitOffset != rgb->depth) {
@@ -166,12 +157,10 @@ static avifBool avifPrepareReformatState(const avifImage * image, const avifRGBI
         state->yuv.mode = AVIF_REFORMAT_MODE_IDENTITY;
     } else if (image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO) {
         state->yuv.mode = AVIF_REFORMAT_MODE_YCGCO;
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
     } else if (useYCgCoRe) {
         state->yuv.mode = AVIF_REFORMAT_MODE_YCGCO_RE;
     } else if (useYCgCoRo) {
         state->yuv.mode = AVIF_REFORMAT_MODE_YCGCO_RO;
-#endif
     }
 
     if (state->yuv.mode != AVIF_REFORMAT_MODE_YUV_COEFFICIENTS) {
@@ -196,12 +185,8 @@ static int avifYUVColorSpaceInfoUVToUNorm(avifYUVColorSpaceInfo * info, float v)
 
     // YCgCo performs limited-full range adjustment on R,G,B but the current implementation performs range adjustment
     // on Y,U,V. So YCgCo with limited range is unsupported.
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
     assert((info->mode != AVIF_REFORMAT_MODE_YCGCO && info->mode != AVIF_REFORMAT_MODE_YCGCO_RE && info->mode != AVIF_REFORMAT_MODE_YCGCO_RO) ||
            (info->range == AVIF_RANGE_FULL));
-#else
-    assert((info->mode != AVIF_REFORMAT_MODE_YCGCO) || (info->range == AVIF_RANGE_FULL));
-#endif
 
     if (info->mode == AVIF_REFORMAT_MODE_IDENTITY) {
         unorm = (int)avifRoundf(v * info->rangeY + info->biasY);
@@ -356,7 +341,6 @@ avifResult avifImageRGBToYUV(avifImage * image, const avifRGBImage * rgb)
                             yuvBlock[bI][bJ].y = 0.5f * rgbPixel[1] + 0.25f * (rgbPixel[0] + rgbPixel[2]);
                             yuvBlock[bI][bJ].u = 0.5f * rgbPixel[1] - 0.25f * (rgbPixel[0] + rgbPixel[2]);
                             yuvBlock[bI][bJ].v = 0.5f * (rgbPixel[0] - rgbPixel[2]);
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
                         } else if (state.yuv.mode == AVIF_REFORMAT_MODE_YCGCO_RE || state.yuv.mode == AVIF_REFORMAT_MODE_YCGCO_RO) {
                             // Formulas from JVET-U0093.
                             const int R = (int)avifRoundf(AVIF_CLAMP(rgbPixel[0] * rgbMaxChannelF, 0.0f, rgbMaxChannelF));
@@ -368,7 +352,6 @@ avifResult avifImageRGBToYUV(avifImage * image, const avifRGBImage * rgb)
                             yuvBlock[bI][bJ].y = (t + (Cg >> 1)) / state.yuv.rangeY;
                             yuvBlock[bI][bJ].u = Cg / state.yuv.rangeUV;
                             yuvBlock[bI][bJ].v = Co / state.yuv.rangeUV;
-#endif
                         } else {
                             float Y = (kr * rgbPixel[0]) + (kg * rgbPixel[1]) + (kb * rgbPixel[2]);
                             yuvBlock[bI][bJ].y = Y;
@@ -773,7 +756,6 @@ static avifResult avifImageYUVAnyToRGBAnySlow(const avifImage * image,
                     G = Y + Cb;
                     B = t - Cr;
                     R = t + Cr;
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
                 } else if (state->yuv.mode == AVIF_REFORMAT_MODE_YCGCO_RE || state->yuv.mode == AVIF_REFORMAT_MODE_YCGCO_RO) {
                     const int YY = unormY;
                     const int Cg = (int)avifRoundf(Cb * yuvMaxChannel);
@@ -785,7 +767,6 @@ static avifResult avifImageYUVAnyToRGBAnySlow(const avifImage * image,
                     G /= rgbMaxChannelF;
                     B /= rgbMaxChannelF;
                     R /= rgbMaxChannelF;
-#endif
                 } else {
                     // Normal YUV
                     R = Y + (2 * (1 - kr)) * Cr;

src/write.c

@@ -1238,6 +1238,13 @@ static avifResult avifValidateGrid(uint32_t gridCols,
             AVIF_ASSERT_OR_RETURN(cellImage->gainMap && cellImage->gainMap->image);
             cellImage = cellImage->gainMap->image;
         }
+#endif
+#if !defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
+        if (cellImage->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE ||
+            cellImage->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO) {
+            avifDiagnosticsPrintf(diag, "YCGCO_R is not enabled for encoding. Please set AVIF_ENABLE_EXPERIMENTAL_YCGCO_R in CMake.");
+            return AVIF_RESULT_INVALID_IMAGE_GRID;
+        }
 #endif
         const uint32_t expectedCellWidth = ((cellIndex + 1) % gridCols) ? tileWidth : bottomRightCell->width;
         const uint32_t expectedCellHeight = (cellIndex < (cellCount - gridCols)) ? tileHeight : bottomRightCell->height;
@@ -1663,7 +1670,6 @@ static avifResult avifEncoderAddImageInternal(avifEncoder * encoder,
                 }
                 cellImage = cellImagePlaceholder;
             }
-
             const avifBool isAlpha = avifIsAlpha(item->itemCategory);
             const int quantizer = isAlpha ? encoder->data->quantizerAlpha
 #if defined(AVIF_ENABLE_EXPERIMENTAL_GAIN_MAP)

tests/gtest/aviflosslesstest.cc

@@ -21,12 +21,10 @@ TEST(BasicTest, EncodeDecodeMatrixCoefficients) {
     const ImagePtr ground_truth_image =
         testutil::ReadImage(data_path, file_name);
 
-    for (auto matrix_coefficient : {
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
-           AVIF_MATRIX_COEFFICIENTS_YCGCO_RE, AVIF_MATRIX_COEFFICIENTS_YCGCO_RO,
-#endif
-               AVIF_MATRIX_COEFFICIENTS_IDENTITY, AVIF_MATRIX_COEFFICIENTS_YCGCO
-         }) {
+    for (auto matrix_coefficient :
+         {AVIF_MATRIX_COEFFICIENTS_IDENTITY, AVIF_MATRIX_COEFFICIENTS_YCGCO,
+          AVIF_MATRIX_COEFFICIENTS_YCGCO_RE,
+          AVIF_MATRIX_COEFFICIENTS_YCGCO_RO}) {
       // Read a ground truth image but ask for certain matrix coefficients.
       ImagePtr image(avifImageCreateEmpty());
       ASSERT_NE(image, nullptr);
@@ -41,14 +39,12 @@ TEST(BasicTest, EncodeDecodeMatrixCoefficients) {
           /*ignoreGainMap=*/true, AVIF_DEFAULT_IMAGE_SIZE_LIMIT, image.get(),
           /*outDepth=*/nullptr, /*sourceTiming=*/nullptr,
           /*frameIter=*/nullptr);
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
       if (matrix_coefficient == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO) {
         // AVIF_MATRIX_COEFFICIENTS_YCGCO_RO does not work because the input
         // depth is not odd.
         ASSERT_EQ(file_format, AVIF_APP_FILE_FORMAT_UNKNOWN);
         continue;
       }
-#endif
       ASSERT_NE(file_format, AVIF_APP_FILE_FORMAT_UNKNOWN);
 
       // Encode.
@@ -60,6 +56,14 @@ TEST(BasicTest, EncodeDecodeMatrixCoefficients) {
       testutil::AvifRwData encoded;
       avifResult result =
           avifEncoderWrite(encoder.get(), image.get(), &encoded);
+
+#if !defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
+      if (matrix_coefficient == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE) {
+        ASSERT_NE(result, AVIF_RESULT_OK);
+        continue;
+      }
+#endif
+
       ASSERT_EQ(result, AVIF_RESULT_OK) << avifResultToString(result);
 
       // Decode to RAM.
@@ -84,11 +88,8 @@ TEST(BasicTest, EncodeDecodeMatrixCoefficients) {
       const bool are_images_equal =
           testutil::AreImagesEqual(*ground_truth_image, *decoded_default);
 
-      if (matrix_coefficient == AVIF_MATRIX_COEFFICIENTS_IDENTITY
-#if defined(AVIF_ENABLE_EXPERIMENTAL_YCGCO_R)
-          || matrix_coefficient == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE
-#endif
-      ) {
+      if (matrix_coefficient == AVIF_MATRIX_COEFFICIENTS_IDENTITY ||
+          matrix_coefficient == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE) {
         ASSERT_TRUE(are_images_equal);
       } else {
         // AVIF_MATRIX_COEFFICIENTS_YCGCO is not lossless because it does not

tests/gtest/avifrgbtoyuvtest.cc

@@ -357,27 +357,40 @@ TEST(RGBToYUVTest, AllMatrixCoefficients) {
             AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400}) {
         for (avifRange yuv_range : {AVIF_RANGE_LIMITED, AVIF_RANGE_FULL}) {
           for (decltype(AVIF_MATRIX_COEFFICIENTS_IDENTITY) matrix_coefficients :
-               {
-                   AVIF_MATRIX_COEFFICIENTS_BT709,
-                   AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED,
-                   AVIF_MATRIX_COEFFICIENTS_FCC,
-                   AVIF_MATRIX_COEFFICIENTS_BT470BG,
-                   AVIF_MATRIX_COEFFICIENTS_BT601,
-                   AVIF_MATRIX_COEFFICIENTS_SMPTE240,
-                   AVIF_MATRIX_COEFFICIENTS_YCGCO,
-                   AVIF_MATRIX_COEFFICIENTS_BT2020_NCL,
-                   AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL
-                   // These are unsupported. See avifPrepareReformatState().
-                   // AVIF_MATRIX_COEFFICIENTS_BT2020_CL
-                   // AVIF_MATRIX_COEFFICIENTS_SMPTE2085
-                   // AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_CL
-                   // AVIF_MATRIX_COEFFICIENTS_ICTCP
-               }) {
+               {AVIF_MATRIX_COEFFICIENTS_BT709,
+                AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED,
+                AVIF_MATRIX_COEFFICIENTS_FCC, AVIF_MATRIX_COEFFICIENTS_BT470BG,
+                AVIF_MATRIX_COEFFICIENTS_BT601,
+                AVIF_MATRIX_COEFFICIENTS_SMPTE240,
+                AVIF_MATRIX_COEFFICIENTS_YCGCO,
+                AVIF_MATRIX_COEFFICIENTS_BT2020_NCL,
+                AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL,
+                // These are unsupported. See avifPrepareReformatState().
+                // AVIF_MATRIX_COEFFICIENTS_BT2020_CL
+                // AVIF_MATRIX_COEFFICIENTS_SMPTE2085
+                // AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_CL
+                // AVIF_MATRIX_COEFFICIENTS_ICTCP
+                AVIF_MATRIX_COEFFICIENTS_YCGCO_RE,
+                AVIF_MATRIX_COEFFICIENTS_YCGCO_RO}) {
             if (matrix_coefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO &&
                 yuv_range == AVIF_RANGE_LIMITED) {
               // See avifPrepareReformatState().
               continue;
             }
+            if ((matrix_coefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE &&
+                 yuv_depth - 2 != rgb_depth) ||
+                (matrix_coefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO &&
+                 yuv_depth - 1 != rgb_depth)) {
+              // See avifPrepareReformatState().
+              continue;
+            }
+            if ((matrix_coefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RE ||
+                 matrix_coefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO) &&
+                yuv_range != AVIF_RANGE_FULL) {
+              // YCgCo-R is for lossless.
+              continue;
+            }
+
             for (avifChromaDownsampling chroma_downsampling :
                  {AVIF_CHROMA_DOWNSAMPLING_FASTEST,
                   AVIF_CHROMA_DOWNSAMPLING_BEST_QUALITY}) {
@@ -458,6 +471,10 @@ constexpr avifMatrixCoefficients kMatrixCoefficientsBT709 =
     AVIF_MATRIX_COEFFICIENTS_BT709;
 constexpr avifMatrixCoefficients kMatrixCoefficientsIdentity =
     AVIF_MATRIX_COEFFICIENTS_IDENTITY;
+constexpr avifMatrixCoefficients kMatrixCoefficientsYCgCoRe =
+    AVIF_MATRIX_COEFFICIENTS_YCGCO_RE;
+constexpr avifMatrixCoefficients kMatrixCoefficientsYCgCoRo =
+    AVIF_MATRIX_COEFFICIENTS_YCGCO_RO;
 
 // This is the default avifenc setup when encoding from 8b PNG files to AVIF.
 INSTANTIATE_TEST_SUITE_P(
@@ -592,6 +609,20 @@ INSTANTIATE_TEST_SUITE_P(MonochromeLossless16b, RGBToYUVTest,
                                  /*max_abs_average_diff=*/Values(0.),
                                  /*min_psnr=*/Values(99.)));
 
+// Tests YCGCO_R are lossless.
+INSTANTIATE_TEST_SUITE_P(YCgCo_R8b, RGBToYUVTest,
+                         Combine(/*rgb_depth=*/Values(8),
+                                 /*yuv_depth=*/Values(10),
+                                 Values(AVIF_RGB_FORMAT_RGBA),
+                                 Values(AVIF_PIXEL_FORMAT_YUV444),
+                                 Values(AVIF_RANGE_FULL),
+                                 Values(kMatrixCoefficientsYCgCoRe),
+                                 Values(AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC),
+                                 /*add_noise=*/Values(true),
+                                 /*rgb_step=*/Values(101),
+                                 /*max_abs_average_diff=*/Values(0.),
+                                 /*min_psnr=*/Values(99.)));
+
 // Coverage for reformat_libsharpyuv.c.
 INSTANTIATE_TEST_SUITE_P(
     SharpYuv8Bit, RGBToYUVTest,