Implement support for P010 GpuMemoryBuffers.

This just fixes issues with the existing P010 GpuMemoryBuffer support
and enables (but doesn't use) that support on macOS for VideoFrames.

P010 GMBs while somewhat implemented did not actually work in the
renderer since the flag which indicates if they're available wasn't
setup correctly in the IPC configuration for FeatureInfo.

Bug: 1101041
Change-Id: I9f96c2a920d34a352909f88f8548fa0348f98703
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2527589Reviewed-by: Frank Liberato <liberato@chromium.org>
Reviewed-by: ccameron <ccameron@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Auto-Submit: Dale Curtis <dalecurtis@chromium.org>
Commit-Queue: Zhenyao Mo <zmo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#825645}

components/viz/service/display/overlay_candidate.cc

@@ -31,7 +31,8 @@ const SkScalar kEpsilon = std::numeric_limits<float>::epsilon();
 const gfx::BufferFormat kOverlayFormats[] = {
     gfx::BufferFormat::RGBX_8888, gfx::BufferFormat::RGBA_8888,
     gfx::BufferFormat::BGRX_8888, gfx::BufferFormat::BGRA_8888,
-    gfx::BufferFormat::BGR_565,   gfx::BufferFormat::YUV_420_BIPLANAR};
+    gfx::BufferFormat::BGR_565,   gfx::BufferFormat::YUV_420_BIPLANAR,
+    gfx::BufferFormat::P010};
 
 enum Axis { NONE, AXIS_POS_X, AXIS_NEG_X, AXIS_POS_Y, AXIS_NEG_Y };
 

components/viz/service/display_embedder/skia_output_surface_impl.cc

@@ -1010,7 +1010,8 @@ GrBackendFormat SkiaOutputSurfaceImpl::GetGrBackendFormatForTexture(
 #if BUILDFLAG(ENABLE_VULKAN)
     if (!ycbcr_info) {
       // YCbCr info is required for YUV images.
-      DCHECK(resource_format != YVU_420 && resource_format != YUV_420_BIPLANAR);
+      DCHECK(resource_format != YVU_420 &&
+             resource_format != YUV_420_BIPLANAR && resource_format != P010);
       return GrBackendFormat::MakeVk(ToVkFormat(resource_format));
     }
 

content/renderer/media/gpu/gpu_video_accelerator_factories_impl.cc

@@ -430,6 +430,10 @@ GpuVideoAcceleratorFactoriesImpl::VideoFrameOutputFormat(
   const size_t bit_depth = media::BitDepth(pixel_format);
   if (bit_depth > 8) {
 #if !defined(OS_MAC)
+    // TODO(crbug.com/1101041): Enable P010 support for macOS.
+    if (capabilities.image_ycbcr_p010 && bit_depth == 10)
+      return media::GpuVideoAcceleratorFactories::OutputFormat::P010;
+
     // If high bit depth rendering is enabled, bail here, otherwise try and use
     // XR30 storage, and if not and we support RG textures, use those, albeit at
     // a reduced bit depth of 8 bits per component.

gpu/command_buffer/build_raster_cmd_buffer.py

@@ -135,7 +135,7 @@ _NAMED_TYPE_INFO = {
       'viz::ResourceFormat::BGRA_1010102',
       'viz::ResourceFormat::YVU_420',
       'viz::ResourceFormat::YUV_420_BIPLANAR',
-
+      'viz::ResourceFormat::P010',
     ],
     'invalid': [
       'viz::ResourceFormat::ETC1',

gpu/command_buffer/service/feature_info.cc

@@ -208,6 +208,8 @@ FeatureInfo::FeatureInfo(
   feature_flags_.chromium_image_ycbcr_p010 = base::Contains(
       gpu_feature_info.supported_buffer_formats_for_allocation_and_texturing,
       gfx::BufferFormat::P010);
+#elif defined(OS_MAC)
+  feature_flags_.chromium_image_ycbcr_p010 = base::mac::IsAtLeastOS11();
 #endif
 }
 

gpu/command_buffer/service/raster_cmd_validation_implementation_autogen.h

@@ -81,6 +81,7 @@ static const viz::ResourceFormat valid_viz_resource_format_table[] = {
     viz::ResourceFormat::RGBX_8888,    viz::ResourceFormat::BGRX_8888,
     viz::ResourceFormat::RGBA_1010102, viz::ResourceFormat::BGRA_1010102,
     viz::ResourceFormat::YVU_420,      viz::ResourceFormat::YUV_420_BIPLANAR,
+    viz::ResourceFormat::P010,
 };
 
 Validators::Validators()

gpu/ipc/common/gpu_command_buffer_traits_multi.h

@@ -127,6 +127,7 @@ IPC_STRUCT_TRAITS_BEGIN(gpu::Capabilities)
   IPC_STRUCT_TRAITS_MEMBER(image_ycbcr_420v_disabled_for_video_frames)
   IPC_STRUCT_TRAITS_MEMBER(image_ar30)
   IPC_STRUCT_TRAITS_MEMBER(image_ab30)
+  IPC_STRUCT_TRAITS_MEMBER(image_ycbcr_p010)
   IPC_STRUCT_TRAITS_MEMBER(render_buffer_format_bgra8888)
   IPC_STRUCT_TRAITS_MEMBER(occlusion_query)
   IPC_STRUCT_TRAITS_MEMBER(occlusion_query_boolean)

gpu/ipc/common/gpu_memory_buffer_support.cc

@@ -92,7 +92,8 @@ bool GpuMemoryBufferSupport::IsNativeGpuMemoryBufferConfigurationSupported(
              format == gfx::BufferFormat::R_8 ||
              format == gfx::BufferFormat::RGBA_F16 ||
              format == gfx::BufferFormat::BGRA_1010102 ||
-             format == gfx::BufferFormat::YUV_420_BIPLANAR;
+             format == gfx::BufferFormat::YUV_420_BIPLANAR ||
+             format == gfx::BufferFormat::P010;
     case gfx::BufferUsage::SCANOUT_VDA_WRITE:
     case gfx::BufferUsage::SCANOUT_CAMERA_READ_WRITE:
     case gfx::BufferUsage::CAMERA_AND_CPU_READ_WRITE:

media/video/gpu_memory_buffer_video_frame_pool.cc

@@ -24,6 +24,7 @@
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
+#include "base/sys_byteorder.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
@@ -239,6 +240,9 @@ gfx::BufferFormat GpuMemoryBufferFormat(
     case GpuVideoAcceleratorFactories::OutputFormat::I420:
       DCHECK_LE(plane, 2u);
       return gfx::BufferFormat::R_8;
+    case GpuVideoAcceleratorFactories::OutputFormat::P010:
+      DCHECK_LE(plane, 1u);
+      return gfx::BufferFormat::P010;
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_SINGLE_GMB:
       DCHECK_LE(plane, 1u);
       return gfx::BufferFormat::YUV_420_BIPLANAR;
@@ -273,6 +277,7 @@ size_t PlanesPerCopy(GpuVideoAcceleratorFactories::OutputFormat format) {
       return 1;
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_DUAL_GMB:
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_SINGLE_GMB:
+    case GpuVideoAcceleratorFactories::OutputFormat::P010:
       return 2;
     case GpuVideoAcceleratorFactories::OutputFormat::XR30:
     case GpuVideoAcceleratorFactories::OutputFormat::XB30:
@@ -292,6 +297,8 @@ VideoPixelFormat VideoFormat(
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_SINGLE_GMB:
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_DUAL_GMB:
       return PIXEL_FORMAT_NV12;
+    case GpuVideoAcceleratorFactories::OutputFormat::P010:
+      return PIXEL_FORMAT_P016LE;
     case GpuVideoAcceleratorFactories::OutputFormat::BGRA:
       return PIXEL_FORMAT_ARGB;
     case GpuVideoAcceleratorFactories::OutputFormat::RGBA:
@@ -312,6 +319,8 @@ size_t NumGpuMemoryBuffers(GpuVideoAcceleratorFactories::OutputFormat format) {
   switch (format) {
     case GpuVideoAcceleratorFactories::OutputFormat::I420:
       return 3;
+    case GpuVideoAcceleratorFactories::OutputFormat::P010:
+      return 1;
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_SINGLE_GMB:
       return 1;
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_DUAL_GMB:
@@ -375,6 +384,56 @@ void CopyRowsToI420Buffer(int first_row,
   }
 }
 
+void CopyRowsToP010Buffer(int first_row,
+                          int rows,
+                          int bytes_per_row,
+                          const VideoFrame* source_frame,
+                          uint8_t* dest_y,
+                          int dest_stride_y,
+                          uint8_t* dest_uv,
+                          int dest_stride_uv,
+                          base::OnceClosure done) {
+  base::ScopedClosureRunner done_runner(std::move(done));
+  TRACE_EVENT2("media", "CopyRowsToP010Buffer", "bytes_per_row", bytes_per_row,
+               "rows", rows);
+
+  if (!dest_y || !dest_uv)
+    return;
+
+  DCHECK_NE(dest_stride_y, 0);
+  DCHECK_NE(dest_stride_uv, 0);
+  DCHECK_LE(bytes_per_row, std::abs(dest_stride_y));
+  DCHECK_LE(bytes_per_row, std::abs(dest_stride_uv));
+  DCHECK_EQ(0, first_row % 2);
+  DCHECK_EQ(source_frame->format(), PIXEL_FORMAT_YUV420P10);
+  DCHECK_LE(bytes_per_row, source_frame->stride(VideoFrame::kYPlane));
+
+  // TODO(crbug.com/libyuv/873): Replace this with a libyuv optimized path or at
+  // least add a SIMD variant.
+  for (int r = first_row; r < first_row + rows; ++r) {
+    const uint16_t* src = reinterpret_cast<const uint16_t*>(
+        source_frame->visible_data(VideoFrame::kYPlane) +
+        r * source_frame->stride(VideoFrame::kYPlane));
+    uint16_t* dest = reinterpret_cast<uint16_t*>(dest_y + r * dest_stride_y);
+    for (int c = 0; c < bytes_per_row / 2; ++c)
+      *dest++ = *src++ << 6;
+  }
+
+  for (int r = first_row / 2; r < (first_row + rows) / 2; ++r) {
+    const uint16_t* u_src = reinterpret_cast<const uint16_t*>(
+        source_frame->visible_data(VideoFrame::kUPlane) +
+        r * source_frame->stride(VideoFrame::kUPlane));
+    const uint16_t* v_src = reinterpret_cast<const uint16_t*>(
+        source_frame->visible_data(VideoFrame::kVPlane) +
+        r * source_frame->stride(VideoFrame::kVPlane));
+    uint16_t* dest = reinterpret_cast<uint16_t*>(dest_uv + r * dest_stride_uv);
+    for (int c = 0; c < bytes_per_row / 4; ++c) {
+      *dest++ = *u_src++ << 6;
+      *dest++ = *v_src++ << 6;
+    }
+  }
+}
+
 void CopyRowsToNV12Buffer(int first_row,
                           int rows,
                           int bytes_per_row,
@@ -530,6 +589,7 @@ gfx::Size CodedSize(const VideoFrame* video_frame,
   gfx::Size output;
   switch (output_format) {
     case GpuVideoAcceleratorFactories::OutputFormat::I420:
+    case GpuVideoAcceleratorFactories::OutputFormat::P010:
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_SINGLE_GMB:
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_DUAL_GMB:
       DCHECK((video_frame->visible_rect().y() & 1) == 0);
@@ -588,9 +648,7 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::CreateHardwareFrame(
     // Supported cases.
     case PIXEL_FORMAT_YV12:
     case PIXEL_FORMAT_I420:
-    case PIXEL_FORMAT_YUV420P9:
     case PIXEL_FORMAT_YUV420P10:
-    case PIXEL_FORMAT_YUV420P12:
     case PIXEL_FORMAT_I420A:
       break;
     // Unsupported cases.
@@ -606,9 +664,11 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::CreateHardwareFrame(
     case PIXEL_FORMAT_RGB24:
     case PIXEL_FORMAT_MJPEG:
     case PIXEL_FORMAT_YUV422P9:
+    case PIXEL_FORMAT_YUV420P9:
     case PIXEL_FORMAT_YUV444P9:
     case PIXEL_FORMAT_YUV422P10:
     case PIXEL_FORMAT_YUV444P10:
+    case PIXEL_FORMAT_YUV420P12:
     case PIXEL_FORMAT_YUV422P12:
     case PIXEL_FORMAT_YUV444P12:
     case PIXEL_FORMAT_Y16:
@@ -796,6 +856,18 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::CopyVideoFrameToGpuMemoryBuffers(
                              buffer->stride(0), barrier));
           break;
         }
+        case GpuVideoAcceleratorFactories::OutputFormat::P010:
+          // Using base::Unretained(video_frame) here is safe because |barrier|
+          // keeps refptr of |video_frame| until all copy tasks are done.
+          worker_task_runner_->PostTask(
+              FROM_HERE,
+              base::BindOnce(
+                  &CopyRowsToP010Buffer, row, rows_to_copy,
+                  coded_size.width() * 2, base::Unretained(video_frame.get()),
+                  static_cast<uint8_t*>(buffer->memory(0)), buffer->stride(0),
+                  static_cast<uint8_t*>(buffer->memory(1)), buffer->stride(1),
+                  barrier));
+          break;
         case GpuVideoAcceleratorFactories::OutputFormat::NV12_SINGLE_GMB:
           // Using base::Unretained(video_frame) here is safe because |barrier|
           // keeps refptr of |video_frame| until all copy tasks are done.
@@ -936,6 +1008,7 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::
     case GpuVideoAcceleratorFactories::OutputFormat::I420:
       allow_overlay = video_frame->metadata()->allow_overlay;
       break;
+    case GpuVideoAcceleratorFactories::OutputFormat::P010:
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_SINGLE_GMB:
       allow_overlay = true;
       break;

media/video/gpu_memory_buffer_video_frame_pool_unittest.cc

@@ -65,6 +65,7 @@ class GpuMemoryBufferVideoFramePoolTest : public ::testing::Test {
 
     const VideoPixelFormat format =
         (bit_depth > 8) ? PIXEL_FORMAT_YUV420P10 : PIXEL_FORMAT_I420;
+    const int multiplier = format == PIXEL_FORMAT_YUV420P10 ? 2 : 1;
     DCHECK_LE(dimension, kDimension);
     const gfx::Size size(dimension, dimension);
 
@@ -75,9 +76,9 @@ class GpuMemoryBufferVideoFramePoolTest : public ::testing::Test {
                   size.width() - visible_rect_crop,
                   size.height() - visible_rect_crop),  // visible_rect
         size,                                          // natural_size
-        size.width(),                                  // y_stride
-        size.width() / 2,                              // u_stride
-        size.width() / 2,                              // v_stride
+        size.width() * multiplier,                     // y_stride
+        size.width() * multiplier / 2,                 // u_stride
+        size.width() * multiplier / 2,                 // v_stride
         y_data,                                        // y_data
         u_data,                                        // u_data
         v_data,                                        // v_data
@@ -326,6 +327,37 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareXR30Frame) {
   EXPECT_EQ(as_xr30(0, 311, 0), *static_cast<uint32_t*>(memory));
 }
 
+TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareP010Frame) {
+  scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10, 10);
+  scoped_refptr<VideoFrame> frame;
+  mock_gpu_factories_->SetVideoFrameOutputFormat(
+      media::GpuVideoAcceleratorFactories::OutputFormat::P010);
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      software_frame, base::BindOnce(MaybeCreateHardwareFrameCallback, &frame));
+
+  RunUntilIdle();
+
+  EXPECT_NE(software_frame.get(), frame.get());
+  EXPECT_EQ(PIXEL_FORMAT_P016LE, frame->format());
+  EXPECT_EQ(1u, frame->NumTextures());
+  EXPECT_EQ(1u, sii_->shared_image_count());
+  EXPECT_TRUE(frame->metadata()->read_lock_fences_enabled);
+
+  EXPECT_EQ(1u, mock_gpu_factories_->created_memory_buffers().size());
+  mock_gpu_factories_->created_memory_buffers()[0]->Map();
+
+  const uint16_t* y_memory = reinterpret_cast<uint16_t*>(
+      mock_gpu_factories_->created_memory_buffers()[0]->memory(0));
+  EXPECT_EQ(software_frame->visible_data(VideoFrame::kYPlane)[0] << 6,
+            y_memory[0]);
+  const uint16_t* uv_memory = reinterpret_cast<uint16_t*>(
+      mock_gpu_factories_->created_memory_buffers()[0]->memory(1));
+  EXPECT_EQ(software_frame->visible_data(VideoFrame::kUPlane)[0] << 6,
+            uv_memory[0]);
+  EXPECT_EQ(software_frame->visible_data(VideoFrame::kVPlane)[0] << 6,
+            uv_memory[1]);
+}
+
 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareXR30FrameBT709) {
   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10, 10);
   software_frame->set_color_space(gfx::ColorSpace::CreateREC709());

media/video/gpu_video_accelerator_factories.h

@@ -67,6 +67,7 @@ class MEDIA_EXPORT GpuVideoAcceleratorFactories {
     XB30,             // 10:10:10:2 RGBX in one GMB
     RGBA,             // One 8:8:8:8 RGBA
     BGRA,             // One 8:8:8:8 BGRA (Usually Mac)
+    P010,             // One P010 GMB.
   };
 
   enum class Supported {

media/video/mock_gpu_video_accelerator_factories.cc

@@ -28,6 +28,7 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
     DCHECK(gfx::BufferFormat::R_8 == format_ ||
            gfx::BufferFormat::RG_88 == format_ ||
            gfx::BufferFormat::YUV_420_BIPLANAR == format_ ||
+           gfx::BufferFormat::P010 == format_ ||
            gfx::BufferFormat::BGRA_1010102 == format_ ||
            gfx::BufferFormat::RGBA_1010102 == format_ ||
            gfx::BufferFormat::RGBA_8888 == format_ ||