media: replace LUMINANCE_F16 by RG_88 for 9/10-bit h264 videos

cc/resources/video_resource_updater.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bit_cast.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/resource_util.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 
@@ skipping 119 matching lines @@
 void VideoResourceUpdater::PlaneResource::SetUniqueId(int unique_frame_id,
                                                       size_t plane_index) {
   DCHECK_EQ(ref_count_, 1);
   plane_index_ = plane_index;
   unique_frame_id_ = unique_frame_id;
   has_unique_frame_id_and_plane_index_ = true;
 }
 
 VideoFrameExternalResources::VideoFrameExternalResources()
     : type(NONE),
+      format(RGBA_8888),
       read_lock_fences_enabled(false),
       offset(0.0f),
       multiplier(1.0f),
       bits_per_channel(8) {}
 
 VideoFrameExternalResources::VideoFrameExternalResources(
     const VideoFrameExternalResources& other) = default;
 
 VideoFrameExternalResources::~VideoFrameExternalResources() {}
 
@@ skipping 131 matching lines @@
                                           uint16_t* dst) {
   // Source and dest stride can be zero since we're only copying
   // one row at a time.
   int stride = 0;
   // Maximum value used in |src|.
   int max_value = (1 << bits_per_channel) - 1;
   int rows = 1;
   libyuv::HalfFloatPlane(src, stride, dst, stride, 1.0f / max_value, num, rows);
 }
 
+ResourceFormat VideoResourceUpdater::YuvResourceFormat(int bits) const {
+  if (!context_provider_)
+    return LUMINANCE_8;
+
+  const auto caps = context_provider_->ContextCapabilities();
+  if (caps.disable_one_component_textures)
+    return RGBA_8888;
+
+  ResourceFormat yuv_resource_format = caps.texture_rg ? RED_8 : LUMINANCE_8;
+  if (bits <= 8)
+    return yuv_resource_format;
+
+  if (caps.texture_half_float_linear)
+    return LUMINANCE_F16;
+
+  if (base::FeatureList::IsEnabled(media::kUseRGTexture) || use_rg_for_testing_)
+    return caps.texture_rg ? RG_88 : RGBA_8888;
+
+  return yuv_resource_format;
+}
+
 VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
     scoped_refptr<media::VideoFrame> video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForSoftwarePlanes");
   const media::VideoPixelFormat input_frame_format = video_frame->format();
 
   // TODO(hubbe): Make this a video frame method.
+  // TODO(dshwang): handle YUV4XXPX by GMBs pool code. crbug.com/445071
   int bits_per_channel = 0;
   switch (input_frame_format) {
     case media::PIXEL_FORMAT_UNKNOWN:
       NOTREACHED();
     // Fall through!
     case media::PIXEL_FORMAT_I420:
     case media::PIXEL_FORMAT_YV12:
     case media::PIXEL_FORMAT_YV16:
     case media::PIXEL_FORMAT_YV12A:
     case media::PIXEL_FORMAT_YV24:
@@ skipping 23 matching lines @@
     case media::PIXEL_FORMAT_YUV420P12:
     case media::PIXEL_FORMAT_YUV422P12:
     case media::PIXEL_FORMAT_YUV444P12:
       bits_per_channel = 12;
       break;
     case media::PIXEL_FORMAT_Y16:
       bits_per_channel = 16;
       break;
   }
 
-  // TODO(dshwang): support PIXEL_FORMAT_Y16. crbug.com/624436
-  DCHECK_NE(bits_per_channel, 16);
-
   // Only YUV software video frames are supported.
   if (!media::IsYuvPlanar(input_frame_format)) {
     NOTREACHED() << media::VideoPixelFormatToString(input_frame_format);
     return VideoFrameExternalResources();
   }
 
-  const bool software_compositor = context_provider_ == NULL;
+  const bool software_compositor = context_provider_ == nullptr;
+  bool disable_one_component_textures = true;
+  if (!software_compositor) {
+    const auto caps = context_provider_->ContextCapabilities();
+    disable_one_component_textures = caps.disable_one_component_textures;
+  }
 
-  ResourceFormat output_resource_format =
-      resource_provider_->YuvResourceFormat(bits_per_channel);
+  ResourceFormat output_resource_format = YuvResourceFormat(bits_per_channel);
 
   // If GPU compositing is enabled, but the output resource format
   // returned by the resource provider is RGBA_8888, then a GPU driver
   // bug workaround requires that YUV frames must be converted to RGB
   // before texture upload.
   bool texture_needs_rgb_conversion =
-      !software_compositor &&
-      output_resource_format == ResourceFormat::RGBA_8888;
+      !software_compositor && disable_one_component_textures;
   size_t output_plane_count = media::VideoFrame::NumPlanes(input_frame_format);
 
   // TODO(skaslev): If we're in software compositing mode, we do the YUV -> RGB
   // conversion here. That involves an extra copy of each frame to a bitmap.
   // Obviously, this is suboptimal and should be addressed once ubercompositor
   // starts shaping up.
   if (software_compositor || texture_needs_rgb_conversion) {
     output_resource_format = kRGBResourceFormat;
     output_plane_count = 1;
     bits_per_channel = 8;
@@ skipping 26 matching lines @@
     ResourceList::iterator resource_it = RecycleOrAllocateResource(
         output_plane_resource_size, output_resource_format,
         video_frame->ColorSpace(), software_compositor, is_immutable,
         video_frame->unique_id(), i);
 
     resource_it->add_ref();
     plane_resources.push_back(resource_it);
   }
 
   VideoFrameExternalResources external_resources;
-
   external_resources.bits_per_channel = bits_per_channel;
+  external_resources.format = output_resource_format;
 
   if (software_compositor || texture_needs_rgb_conversion) {
     DCHECK_EQ(plane_resources.size(), 1u);
     PlaneResource& plane_resource = *plane_resources[0];
     DCHECK_EQ(plane_resource.resource_format(), kRGBResourceFormat);
     DCHECK_EQ(software_compositor, plane_resource.mailbox().IsZero());
 
     if (!plane_resource.Matches(video_frame->unique_id(), 0)) {
       // We need to transfer data from |video_frame| to the plane resource.
       if (software_compositor) {
@@ skipping 37 matching lines @@
                                  plane_resource.resource_id()));
       mailbox.set_color_space(video_frame->ColorSpace());
       external_resources.mailboxes.push_back(mailbox);
       external_resources.release_callbacks.push_back(base::Bind(
           &RecycleResource, AsWeakPtr(), plane_resource.resource_id()));
       external_resources.type = VideoFrameExternalResources::RGBA_RESOURCE;
     }
     return external_resources;
   }
 
-  for (size_t i = 0; i < plane_resources.size(); ++i) {
-    PlaneResource& plane_resource = *plane_resources[i];
+  const bool highbit_rg_rgba_fallback =
+      bits_per_channel > 8 && output_resource_format == RGBA_8888;
+  bool needs_conversion = false;
+  int shift = 0;
+  if (output_resource_format == LUMINANCE_F16) {
+    // LUMINANCE_F16 uses half-floats, so we always need a conversion step.
+    needs_conversion = true;
+  } else if (output_resource_format == RG_88) {
+    // RG_88 can represent 16bit int, so we don't need a conversion step.
+    needs_conversion = false;
+  } else if (highbit_rg_rgba_fallback) {
+    // RG channels is used to represent 16bit int.
+    needs_conversion = true;
+  } else if (bits_per_channel > 8) {
+    // If bits_per_channel > 8 and we can't use RG_88, we need to
+    // shift the data down and create an 8-bit texture.
+    needs_conversion = true;
+    shift = bits_per_channel - 8;
+    external_resources.bits_per_channel = 8;
+  }
+
+  for (size_t plane = 0; plane < plane_resources.size(); ++plane) {
+    PlaneResource& plane_resource = *plane_resources[plane];
     // Update each plane's resource id with its content.
-    DCHECK_EQ(plane_resource.resource_format(),
-              resource_provider_->YuvResourceFormat(bits_per_channel));
+    DCHECK_EQ(plane_resource.resource_format(), output_resource_format);
 
-    if (!plane_resource.Matches(video_frame->unique_id(), i)) {
+    if (!plane_resource.Matches(video_frame->unique_id(), plane)) {
       // TODO(hubbe): Move all conversion (and upload?) code to media/.
       // We need to transfer data from |video_frame| to the plane resource.
       // TODO(reveman): Can use GpuMemoryBuffers here to improve performance.
 
       // The |resource_size_pixels| is the size of the resource we want to
       // upload to.
       gfx::Size resource_size_pixels = plane_resource.resource_size();
       // The |video_stride_bytes| is the width of the video frame we are
       // uploading (including non-frame data to fill in the stride).
-      int video_stride_bytes = video_frame->stride(i);
+      int video_stride_bytes = video_frame->stride(plane);
 
       size_t bytes_per_row = ResourceUtil::CheckedWidthInBytes<size_t>(
-          resource_size_pixels.width(), plane_resource.resource_format());
+          resource_size_pixels.width(), output_resource_format);
       // Use 4-byte row alignment (OpenGL default) for upload performance.
       // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
       size_t upload_image_stride =
           MathUtil::CheckedRoundUp<size_t>(bytes_per_row, 4u);
 
-      bool needs_conversion = false;
-      int shift = 0;
-
-      // LUMINANCE_F16 uses half-floats, so we always need a conversion step.
-      if (plane_resource.resource_format() == LUMINANCE_F16) {
-        needs_conversion = true;
-      } else if (bits_per_channel > 8) {
-        // If bits_per_channel > 8 and we can't use LUMINANCE_F16, we need to
-        // shift the data down and create an 8-bit texture.
-        needs_conversion = true;
-        shift = bits_per_channel - 8;
-      }
       const uint8_t* pixels;
       if (static_cast<int>(upload_image_stride) == video_stride_bytes &&
           !needs_conversion) {
-        pixels = video_frame->data(i);
+        pixels = video_frame->data(plane);
       } else {
         // Avoid malloc for each frame/plane if possible.
         size_t needed_size =
             upload_image_stride * resource_size_pixels.height();
         if (upload_pixels_.size() < needed_size)
           upload_pixels_.resize(needed_size);
 
         for (int row = 0; row < resource_size_pixels.height(); ++row) {
-          if (plane_resource.resource_format() == LUMINANCE_F16) {
+          if (output_resource_format == LUMINANCE_F16) {
             uint16_t* dst = reinterpret_cast<uint16_t*>(
                 &upload_pixels_[upload_image_stride * row]);
             const uint16_t* src = reinterpret_cast<uint16_t*>(
-                video_frame->data(i) + (video_stride_bytes * row));
+                video_frame->data(plane) + (video_stride_bytes * row));
             if (bits_per_channel <= 10) {
               // Micro-benchmarking indicates that the compiler does
               // a good enough job of optimizing this loop that trying
               // to manually operate on one uint64 at a time is not
               // actually helpful.
               // Note to future optimizers: Benchmark your optimizations!
               for (size_t i = 0; i < bytes_per_row / 2; i++)
                 dst[i] = src[i] | 0x3800;
             } else {
               MakeHalfFloats(src, bits_per_channel, bytes_per_row / 2, dst);
             }
+          } else if (highbit_rg_rgba_fallback) {
+            uint32_t* dst = reinterpret_cast<uint32_t*>(
+                &upload_pixels_[upload_image_stride * row]);
+            const uint16_t* src = reinterpret_cast<uint16_t*>(
+                video_frame->data(plane) + (video_stride_bytes * row));
+            for (int i = 0; i < resource_size_pixels.width(); i++)
+              dst[i] = src[i];
           } else if (shift != 0) {
             // We have more-than-8-bit input which we need to shift
             // down to fit it into an 8-bit texture.
             uint8_t* dst = &upload_pixels_[upload_image_stride * row];
             const uint16_t* src = reinterpret_cast<uint16_t*>(
-                video_frame->data(i) + (video_stride_bytes * row));
+                video_frame->data(plane) + (video_stride_bytes * row));
             for (size_t i = 0; i < bytes_per_row; i++)
               dst[i] = src[i] >> shift;
           } else {
             // Input and output are the same size and format, but
             // differ in stride, copy one row at a time.
             uint8_t* dst = &upload_pixels_[upload_image_stride * row];
             const uint8_t* src =
-                video_frame->data(i) + (video_stride_bytes * row);
+                video_frame->data(plane) + (video_stride_bytes * row);
             memcpy(dst, src, bytes_per_row);
           }
         }
         pixels = &upload_pixels_[0];
       }
 
       resource_provider_->CopyToResource(plane_resource.resource_id(), pixels,
                                          resource_size_pixels);
-      plane_resource.SetUniqueId(video_frame->unique_id(), i);
+      plane_resource.SetUniqueId(video_frame->unique_id(), plane);
     }
 
     if (plane_resource.resource_format() == LUMINANCE_F16) {
       // If the input data was 9 or 10 bit, and we output to half-floats,
       // then we used the OR path above, which means that we need to
       // adjust the resource offset and multiplier accordingly. If the
       // input data uses more than 10 bits, it will already be normalized
       // to 0.0..1.0, so there is no need to do anything.
       if (bits_per_channel <= 10) {
         // By OR-ing with 0x3800, 10-bit numbers become half-floats in the
@@ skipping 178 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc