Fix HTML5 video blurry

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>
@@ skipping 361 matching lines @@
 VideoResourceUpdater::NewHalfFloatMaker(int bits_per_channel) {
   if (bits_per_channel < 11) {
     return std::unique_ptr<VideoResourceUpdater::HalfFloatMaker>(
         new HalfFloatMaker_xor(bits_per_channel));
   } else {
     return std::unique_ptr<VideoResourceUpdater::HalfFloatMaker>(
         new HalfFloatMaker_libyuv(bits_per_channel));
   }
 }
 
+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;
+
+  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.
   int bits_per_channel = 0;
   switch (input_frame_format) {
     case media::PIXEL_FORMAT_UNKNOWN:
       NOTREACHED();
@@ skipping 38 matching lines @@
 
   // 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 55 matching lines @@
         // by software.
         video_renderer_->Copy(video_frame, &canvas, media::Context3D());
       } else {
         size_t bytes_per_row = ResourceUtil::CheckedWidthInBytes<size_t>(
             video_frame->coded_size().width(), ResourceFormat::RGBA_8888);
         size_t needed_size = bytes_per_row * video_frame->coded_size().height();
         if (upload_pixels_.size() < needed_size)
           upload_pixels_.resize(needed_size);
 
         media::SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
-            video_frame.get(), &upload_pixels_[0], bytes_per_row);
+            video_frame.get(),
+            media::SkCanvasVideoRenderer::ConvertingSize::CODED,
+            &upload_pixels_[0], bytes_per_row);
 
         resource_provider_->CopyToResource(plane_resource.resource_id(),
                                            &upload_pixels_[0],
                                            plane_resource.resource_size());
       }
       plane_resource.SetUniqueId(video_frame->unique_id(), 0);
     }
 
     if (software_compositor) {
       external_resources.software_resources.push_back(
           plane_resource.resource_id());
       external_resources.software_release_callback = base::Bind(
           &RecycleResource, AsWeakPtr(), plane_resource.resource_id());
       external_resources.type = VideoFrameExternalResources::SOFTWARE_RESOURCE;
     } else {
       // VideoResourceUpdater shares a context with the compositor so
       // a sync token is not required.
       TextureMailbox mailbox(plane_resource.mailbox(), gpu::SyncToken(),
                              resource_provider_->GetResourceTextureTarget(
-                                 plane_resource.resource_id()));
+                                 plane_resource.resource_id()),
+                             plane_resource.resource_size(), false, false);
       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;
   }
 
   std::unique_ptr<HalfFloatMaker> half_float_maker;
-  if (resource_provider_->YuvResourceFormat(bits_per_channel) ==
-      LUMINANCE_F16) {
+  if (YuvResourceFormat(bits_per_channel) == LUMINANCE_F16) {
     half_float_maker = NewHalfFloatMaker(bits_per_channel);
     external_resources.offset = half_float_maker->Offset();
     external_resources.multiplier = half_float_maker->Multiplier();
   }
 
   for (size_t i = 0; i < plane_resources.size(); ++i) {
     PlaneResource& plane_resource = *plane_resources[i];
     // Update each plane's resource id with its content.
     DCHECK_EQ(plane_resource.resource_format(),
-              resource_provider_->YuvResourceFormat(bits_per_channel));
+              YuvResourceFormat(bits_per_channel));
 
     if (!plane_resource.Matches(video_frame->unique_id(), i)) {
       // 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
@@ skipping 221 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc