Use SkYUVAInfo's separate plane config and subsampling enums.

Allows removal of combined enum from Skia:
https://skia-review.googlesource.com/c/skia/+/334161

Bug: skia:10632
Change-Id: I6e89110694ba5808d493d9ff0670727f383a2577
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2533579
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#828528}

cc/paint/oop_pixeltest.cc

@@ -1950,7 +1950,8 @@ TEST_F(OopPixelTest, ConvertYUVToRGB) {
 
   SkYUVAInfo yuva_info(
       {options.resource_size.width(), options.resource_size.height()},
-      SkYUVAInfo::PlanarConfig::kY_U_V_420, kJPEG_Full_SkYUVColorSpace);
+      SkYUVAInfo::PlaneConfig::kY_U_V, SkYUVAInfo::Subsampling::k420,
+      kJPEG_Full_SkYUVColorSpace);
   GrYUVABackendTextures yuva_textures(yuva_info, backend_textures,
                                       kTopLeft_GrSurfaceOrigin);
 
@@ -2068,7 +2069,8 @@ TEST_F(OopPixelTest, ConvertNV12ToRGB) {
 
   SkYUVAInfo yuva_info(
       {options.resource_size.width(), options.resource_size.height()},
-      SkYUVAInfo::PlanarConfig::kY_UV_420, kJPEG_Full_SkYUVColorSpace);
+      SkYUVAInfo::PlaneConfig::kY_UV, SkYUVAInfo::Subsampling::k420,
+      kJPEG_Full_SkYUVColorSpace);
   GrYUVABackendTextures yuva_textures(yuva_info, backend_textures,
                                       kTopLeft_GrSurfaceOrigin);
   auto expected_image = SkImage::MakeFromYUVATextures(

cc/paint/paint_image_unittest.cc

@@ -74,7 +74,8 @@ TEST(PaintImageTest, GetSkImageForFrameNotGeneratorBacked) {
 
 TEST(PaintImageTest, DecodeToYuv420NoAlpha) {
   const SkISize full_size = SkISize::Make(10, 10);
-  SkYUVAInfo yuva_info(full_size, SkYUVAInfo::PlanarConfig::kY_U_V_420,
+  SkYUVAInfo yuva_info(full_size, SkYUVAInfo::PlaneConfig::kY_U_V,
+                       SkYUVAInfo::Subsampling::k420,
                        kJPEG_Full_SkYUVColorSpace);
   SkYUVAPixmapInfo yuva_pixmap_info(yuva_info,
                                     SkYUVAPixmapInfo::DataType::kUnorm8,

cc/test/skia_common.cc

@@ -109,22 +109,32 @@ SkYUVAPixmapInfo GetYUVAPixmapInfo(const gfx::Size& image_size,
     NOTREACHED();
     return SkYUVAPixmapInfo();
   }
-  SkYUVAInfo::PlanarConfig planar_config;
+  SkYUVAInfo::Subsampling subsampling;
   switch (format) {
+    case YUVSubsampling::k410:
+      subsampling = SkYUVAInfo::Subsampling::k410;
+      break;
+    case YUVSubsampling::k411:
+      subsampling = SkYUVAInfo::Subsampling::k411;
+      break;
     case YUVSubsampling::k420:
-      planar_config = SkYUVAInfo::PlanarConfig::kY_U_V_420;
+      subsampling = SkYUVAInfo::Subsampling::k420;
       break;
     case YUVSubsampling::k422:
-      planar_config = SkYUVAInfo::PlanarConfig::kY_U_V_422;
+      subsampling = SkYUVAInfo::Subsampling::k422;
+      break;
+    case YUVSubsampling::k440:
+      subsampling = SkYUVAInfo::Subsampling::k440;
       break;
     case YUVSubsampling::k444:
-      planar_config = SkYUVAInfo::PlanarConfig::kY_U_V_444;
+      subsampling = SkYUVAInfo::Subsampling::k444;
       break;
     default:
       NOTREACHED();
       return SkYUVAPixmapInfo();
   }
-  SkYUVAInfo yuva_info({image_size.width(), image_size.height()}, planar_config,
+  SkYUVAInfo yuva_info({image_size.width(), image_size.height()},
+                       SkYUVAInfo::PlaneConfig::kY_U_V, subsampling,
                        kJPEG_Full_SkYUVColorSpace);
   return SkYUVAPixmapInfo(yuva_info, yuv_data_type, /*row bytes*/ nullptr);
 }

cc/tiles/gpu_image_decode_cache.h

@@ -520,10 +520,7 @@ class CC_EXPORT GpuImageDecodeCache
               bool is_bitmap_backed,
               bool can_do_hardware_accelerated_decode,
               bool do_hardware_accelerated_decode,
-              bool is_yuv_format,
-              SkYUVColorSpace yuv_cs,
-              SkYUVAInfo::PlanarConfig yuv_config,
-              SkYUVAPixmapInfo::DataType yuv_dt);
+              base::Optional<SkYUVAPixmapInfo> yuva_pixmap_info);
 
     bool IsGpuOrTransferCache() const;
     bool HasUploadedData() const;
@@ -537,11 +534,8 @@ class CC_EXPORT GpuImageDecodeCache
     int upload_scale_mip_level;
     bool needs_mips = false;
     bool is_bitmap_backed;
-    bool is_yuv;
     bool is_budgeted = false;
-    base::Optional<SkYUVColorSpace> yuv_color_space;
-    base::Optional<SkYUVAInfo::PlanarConfig> yuv_planar_config;
-    base::Optional<SkYUVAPixmapInfo::DataType> yuv_data_type;
+    base::Optional<SkYUVAPixmapInfo> yuva_pixmap_info;
 
     // If true, this image is no longer in our |persistent_cache_| and will be
     // deleted as soon as its ref count reaches zero.
@@ -642,7 +636,8 @@ class CC_EXPORT GpuImageDecodeCache
       const SkImage* uploaded_v_image,
       const size_t image_width,
       const size_t image_height,
-      const SkYUVAInfo::PlanarConfig yuva_planar_config,
+      const SkYUVAInfo::PlaneConfig yuva_plane_config,
+      const SkYUVAInfo::Subsampling yuva_subsampling,
       const SkYUVColorSpace yuva_color_space,
       sk_sp<SkColorSpace> target_color_space,
       sk_sp<SkColorSpace> decoded_color_space) const;

gpu/command_buffer/service/raster_decoder.cc

@@ -2737,10 +2737,11 @@ void RasterDecoderImpl::DoConvertYUVMailboxesToRGBINTERNAL(
 
     SkISize dest_size =
         SkISize::Make(dest_surface->width(), dest_surface->height());
-    SkYUVAInfo::PlanarConfig planar_config =
-        is_nv12 ? SkYUVAInfo::PlanarConfig::kY_UV_420
-                : SkYUVAInfo::PlanarConfig::kY_U_V_420;
-    SkYUVAInfo yuva_info(dest_size, planar_config, src_color_space);
+    SkYUVAInfo::PlaneConfig plane_config =
+        is_nv12 ? SkYUVAInfo::PlaneConfig::kY_UV
+                : SkYUVAInfo::PlaneConfig::kY_U_V;
+    SkYUVAInfo yuva_info(dest_size, plane_config, SkYUVAInfo::Subsampling::k420,
+                         src_color_space);
     GrYUVABackendTextures yuva_backend_textures(yuva_info, yuva_textures.data(),
                                                 kTopLeft_GrSurfaceOrigin);
     auto result_image =

media/renderers/paint_canvas_video_renderer.cc

@@ -638,31 +638,24 @@ bool ValidFormatForDirectUploading(GrGLenum format, unsigned int type) {
   }
 }
 
-bool VideoPixelFormatAsSkYUVAInfoPlanarConfig(
-    VideoPixelFormat format,
-    SkYUVAInfo::PlanarConfig* config) {
-  // TODO(skbug.com/10632): Add more formats, e.g. I420A, NV12, NV21 when Skia
-  // equivalents are added.
+std::tuple<SkYUVAInfo::PlaneConfig, SkYUVAInfo::Subsampling>
+VideoPixelFormatAsSkYUVAInfoValues(VideoPixelFormat format) {
   // The 9, 10, and 12 bit formats could be added here if GetYUVAPlanes() were
-  // updated to convert data to unorm16/float16.
+  // updated to convert data to unorm16/float16. Similarly, alpha planes and
+  // formats with interleaved planes (e.g. NV12) could  be supported if that
+  // function were updated to not assume 3 separate Y, U, and V planes. Also,
+  // GpuImageDecodeCache would need be able to handle plane configurations
+  // other than 3 separate y, u, and v planes (crbug.com/910276).
   switch (format) {
     case PIXEL_FORMAT_I420:
-      if (config) {
-        *config = SkYUVAInfo::PlanarConfig::kY_U_V_420;
-      }
-      return true;
+      return {SkYUVAInfo::PlaneConfig::kY_U_V, SkYUVAInfo::Subsampling::k420};
     case PIXEL_FORMAT_I422:
-      if (config) {
-        *config = SkYUVAInfo::PlanarConfig::kY_U_V_422;
-      }
-      return true;
+      return {SkYUVAInfo::PlaneConfig::kY_U_V, SkYUVAInfo::Subsampling::k422};
     case PIXEL_FORMAT_I444:
-      if (config) {
-        *config = SkYUVAInfo::PlanarConfig::kY_U_V_444;
-      }
-      return true;
+      return {SkYUVAInfo::PlaneConfig::kY_U_V, SkYUVAInfo::Subsampling::k444};
     default:
-      return false;
+      return {SkYUVAInfo::PlaneConfig::kUnknown,
+              SkYUVAInfo::Subsampling::kUnknown};
   }
 }
 
@@ -704,9 +697,11 @@ class VideoImageGenerator : public cc::PaintImageGenerator {
     // is added for VideoImageGenerator.
     return false;
 #if 0
-    SkYUVAInfo::PlanarConfig planar_config;
-    if (!VideoPixelFormatAsSkYUVAInfoPlanarConfig(frame_->format(),
-                                                  &planar_config)) {
+    SkYUVAInfo::PlaneConfig plane_config;
+    SkYUVAInfo::Subsampling subsampling;
+    std::tie(plane_config, subsampling) =
+        VideoPixelFormatAsSkYUVAInfoValues(frame_->format());
+    if (plane_config == SkYUVAInfo::PlaneConfig::kUnknown) {
       return false;
     }
     if (info) {
@@ -722,8 +717,9 @@ class VideoImageGenerator : public cc::PaintImageGenerator {
           VideoFrame::PlaneSize(frame_->format(), VideoFrame::kYPlane,
                                 gfx::Size(frame_->visible_rect().width(),
                                           frame_->visible_rect().height()));
-      SkYUVAInfo yuva_info = SkYUVAInfo({y_size.width(), y_size.height()},
-                                        planar_config, yuv_color_space);
+      SkYUVAInfo yuva_info =
+          SkYUVAInfo({y_size.width(), y_size.height()}, plane_config,
+                     subsampling, yuv_color_space);
       *info = SkYUVAPixmapInfo(yuva_info, SkYUVAPixmapInfo::DataType::kUnorm8,
                                /* row bytes */ nullptr);
     }
@@ -735,13 +731,15 @@ class VideoImageGenerator : public cc::PaintImageGenerator {
                      size_t frame_index,
                      uint32_t lazy_pixel_ref) override {
     DCHECK_EQ(frame_index, 0u);
-
-    if (!VideoPixelFormatAsSkYUVAInfoPlanarConfig(frame_->format(), nullptr)) {
-      return false;
-    }
-
-    if (!pixmaps.plane(3).dimensions().isEmpty()) {
-      return false;
+    DCHECK_EQ(pixmaps.numPlanes(), 3);
+
+    if (DCHECK_IS_ON()) {
+      SkYUVAInfo::PlaneConfig plane_config;
+      SkYUVAInfo::Subsampling subsampling;
+      std::tie(plane_config, subsampling) =
+          VideoPixelFormatAsSkYUVAInfoValues(frame_->format());
+      DCHECK_EQ(plane_config, pixmaps.yuvaInfo().planeConfig());
+      DCHECK_EQ(subsampling, pixmaps.yuvaInfo().subsampling());
     }
 
     for (int plane = VideoFrame::kYPlane; plane <= VideoFrame::kVPlane;

media/renderers/video_frame_yuv_converter.cc

@@ -40,20 +40,24 @@ sk_sp<SkImage> YUVGrBackendTexturesToSkImage(
     VideoPixelFormat video_format,
     GrBackendTexture* yuv_textures,
     const GrBackendTexture& result_texture) {
-  SkYUVAInfo::PlanarConfig planar_config;
+  SkYUVAInfo::PlaneConfig plane_config;
+  SkYUVAInfo::Subsampling subsampling;
   switch (video_format) {
     case PIXEL_FORMAT_NV12:
-      planar_config = SkYUVAInfo::PlanarConfig::kY_UV_420;
+      plane_config = SkYUVAInfo::PlaneConfig::kY_UV;
+      subsampling = SkYUVAInfo::Subsampling::k420;
       break;
     case PIXEL_FORMAT_I420:
-      planar_config = SkYUVAInfo::PlanarConfig::kY_U_V_420;
+      plane_config = SkYUVAInfo::PlaneConfig::kY_U_V;
+      subsampling = SkYUVAInfo::Subsampling::k420;
       break;
     default:
       NOTREACHED();
       return nullptr;
   }
   SkYUVColorSpace color_space = ColorSpaceToSkYUVColorSpace(video_color_space);
-  SkYUVAInfo yuva_info(result_texture.dimensions(), planar_config, color_space);
+  SkYUVAInfo yuva_info(result_texture.dimensions(), plane_config, subsampling,
+                       color_space);
   GrYUVABackendTextures yuva_backend_textures(yuva_info, yuv_textures,
                                               kTopLeft_GrSurfaceOrigin);
   return SkImage::MakeFromYUVATexturesCopyToExternal(
@@ -115,13 +119,16 @@ bool YUVGrBackendTexturesToSkSurface(GrDirectContext* gr_context,
                                      sk_sp<SkSurface> surface,
                                      bool flip_y,
                                      bool use_visible_rect) {
-  SkYUVAInfo::PlanarConfig planar_config;
+  SkYUVAInfo::PlaneConfig plane_config;
+  SkYUVAInfo::Subsampling subsampling;
   switch (video_frame->format()) {
     case PIXEL_FORMAT_NV12:
-      planar_config = SkYUVAInfo::PlanarConfig::kY_UV_420;
+      plane_config = SkYUVAInfo::PlaneConfig::kY_UV;
+      subsampling = SkYUVAInfo::Subsampling::k420;
       break;
     case PIXEL_FORMAT_I420:
-      planar_config = SkYUVAInfo::PlanarConfig::kY_U_V_420;
+      plane_config = SkYUVAInfo::PlaneConfig::kY_U_V;
+      subsampling = SkYUVAInfo::Subsampling::k420;
       break;
     default:
       NOTREACHED();
@@ -129,7 +136,8 @@ bool YUVGrBackendTexturesToSkSurface(GrDirectContext* gr_context,
   }
   SkYUVAInfo yuva_info(
       {video_frame->coded_size().width(), video_frame->coded_size().height()},
-      planar_config, ColorSpaceToSkYUVColorSpace(video_frame->ColorSpace()));
+      plane_config, subsampling,
+      ColorSpaceToSkYUVColorSpace(video_frame->ColorSpace()));
   auto image = SkImage::MakeFromYUVATextures(
       gr_context,
       GrYUVABackendTextures(yuva_info, yuv_textures, kTopLeft_GrSurfaceOrigin),

third_party/blink/renderer/platform/graphics/image_frame_generator.cc

@@ -38,32 +38,36 @@
 
 namespace blink {
 
-static bool UpdateYUVAInfoPlanarConfigAndWidthBytes(
-    ImageDecoder* decoder,
-    SkYUVAInfo::PlanarConfig* config,
-    size_t component_width_bytes[SkYUVAInfo::kMaxPlanes]) {
-  switch (decoder->GetYUVSubsampling()) {
+SkYUVAInfo::Subsampling SubsamplingToSkiaSubsampling(
+    cc::YUVSubsampling subsampling) {
+  switch (subsampling) {
     case cc::YUVSubsampling::k410:
-      *config = SkYUVAInfo::PlanarConfig::kY_U_V_410;
-      break;
+      return SkYUVAInfo::Subsampling::k410;
     case cc::YUVSubsampling::k411:
-      *config = SkYUVAInfo::PlanarConfig::kY_U_V_411;
-      break;
+      return SkYUVAInfo::Subsampling::k411;
     case cc::YUVSubsampling::k420:
-      *config = SkYUVAInfo::PlanarConfig::kY_U_V_420;
-      break;
+      return SkYUVAInfo::Subsampling::k420;
     case cc::YUVSubsampling::k422:
-      *config = SkYUVAInfo::PlanarConfig::kY_U_V_422;
-      break;
+      return SkYUVAInfo::Subsampling::k422;
     case cc::YUVSubsampling::k440:
-      *config = SkYUVAInfo::PlanarConfig::kY_U_V_440;
-      break;
+      return SkYUVAInfo::Subsampling::k440;
     case cc::YUVSubsampling::k444:
-      *config = SkYUVAInfo::PlanarConfig::kY_U_V_444;
-      break;
-    default:
-      return false;
+      return SkYUVAInfo::Subsampling::k444;
+    case cc::YUVSubsampling::kUnknown:
+      return SkYUVAInfo::Subsampling::kUnknown;
+  }
+}
+
+static bool UpdateYUVAInfoSubsamplingAndWidthBytes(
+    ImageDecoder* decoder,
+    SkYUVAInfo::Subsampling* subsampling,
+    size_t component_width_bytes[SkYUVAInfo::kMaxPlanes]) {
+  SkYUVAInfo::Subsampling tempSubsampling =
+      SubsamplingToSkiaSubsampling(decoder->GetYUVSubsampling());
+  if (tempSubsampling == SkYUVAInfo::Subsampling::kUnknown) {
+    return false;
   }
+  *subsampling = tempSubsampling;
   component_width_bytes[0] = decoder->DecodedYUVWidthBytes(cc::YUVIndex::kY);
   component_width_bytes[1] = decoder->DecodedYUVWidthBytes(cc::YUVIndex::kU);
   component_width_bytes[2] = decoder->DecodedYUVWidthBytes(cc::YUVIndex::kV);
@@ -253,26 +257,29 @@ bool ImageFrameGenerator::GetYUVAInfo(
   DCHECK(decoder);
 
   DCHECK(decoder->CanDecodeToYUV());
-  SkYUVAInfo::PlanarConfig config;
+  SkYUVAInfo::Subsampling subsampling;
   size_t width_bytes[SkYUVAInfo::kMaxPlanes];
-  if (!UpdateYUVAInfoPlanarConfigAndWidthBytes(decoder.get(), &config,
-                                               width_bytes)) {
+  if (!UpdateYUVAInfoSubsamplingAndWidthBytes(decoder.get(), &subsampling,
+                                              width_bytes)) {
     return false;
   }
-  SkYUVAInfo yuva_info(full_size_, config, decoder->GetYUVColorSpace());
+  SkYUVAInfo yuva_info(full_size_, SkYUVAInfo::PlaneConfig::kY_U_V, subsampling,
+                       decoder->GetYUVColorSpace());
   SkYUVAPixmapInfo::DataType dataType;
   if (decoder->GetYUVBitDepth() > 8) {
-    if (supported_data_types.supported(config,
+    if (supported_data_types.supported(SkYUVAInfo::PlaneConfig::kY_U_V,
                                        SkYUVAPixmapInfo::DataType::kUnorm16)) {
       dataType = SkYUVAPixmapInfo::DataType::kUnorm16;
     } else if (supported_data_types.supported(
-                   config, SkYUVAPixmapInfo::DataType::kFloat16)) {
+                   SkYUVAInfo::PlaneConfig::kY_U_V,
+                   SkYUVAPixmapInfo::DataType::kFloat16)) {
       dataType = SkYUVAPixmapInfo::DataType::kFloat16;
     } else {
       return false;
     }
   } else if (supported_data_types.supported(
-                 config, SkYUVAPixmapInfo::DataType::kUnorm8)) {
+                 SkYUVAInfo::PlaneConfig::kY_U_V,
+                 SkYUVAPixmapInfo::DataType::kUnorm8)) {
     dataType = SkYUVAPixmapInfo::DataType::kUnorm8;
   } else {
     return false;