Fix HTML5 video blurry

media/renderers/skcanvas_video_renderer.cc

 // Copyright (c) 2012 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 "media/renderers/skcanvas_video_renderer.h"
 
 #include <limits>
 
 #include "base/macros.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 207 matching lines @@
   }
   ~VideoImageGenerator() override {}
 
  protected:
   bool onGetPixels(const SkImageInfo& info,
                    void* pixels,
                    size_t row_bytes,
                    SkPMColor ctable[],
                    int* ctable_count) override {
     // If skia couldn't do the YUV conversion on GPU, we will on CPU.
-    SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(frame_.get(), pixels,
-                                                        row_bytes);
+    SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
+        frame_.get(), SkCanvasVideoRenderer::ConvertingSize::VISUAL, pixels,
+        row_bytes);
     return true;
   }
 
   bool onQueryYUV8(SkYUVSizeInfo* sizeInfo,
                    SkYUVColorSpace* color_space) const override {
     if (!media::IsYuvPlanar(frame_->format()) ||
         // TODO(rileya): Skia currently doesn't support YUVA conversion. Remove
         // this case once it does. As-is we will fall back on the pure-software
         // path in this case.
         frame_->format() == PIXEL_FORMAT_YV12A) {
@@ skipping 273 matching lines @@
     for (int row = 0; row < video_frame->rows(plane); row++) {
       for (int x = 0; x < width; x++) {
         dst[x] = src[x] >> shift;
       }
       src += video_frame->stride(plane) / 2;
       dst += ret->stride(plane);
     }
   }
   return ret;
 }
+
+const uint8_t* FrameData(const VideoFrame* video_frame,
+                         SkCanvasVideoRenderer::ConvertingSize size_type,
+                         size_t plane) {
+  if (size_type == SkCanvasVideoRenderer::ConvertingSize::VISUAL) {
+    return video_frame->visible_data(plane);
+  }
+  DCHECK(size_type == SkCanvasVideoRenderer::ConvertingSize::CODED);
+  return video_frame->data(plane);
 }
 
+}  // namespace
+
 // static
 void SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
     const VideoFrame* video_frame,
+    ConvertingSize size_type,
     void* rgb_pixels,
     size_t row_bytes) {
   if (!video_frame->IsMappable()) {
     NOTREACHED() << "Cannot extract pixels from non-CPU frame formats.";
     return;
   }
   if (!media::IsYuvPlanar(video_frame->format())) {
     NOTREACHED() << "Non YUV formats are not supported";
     return;
   }
 
+  gfx::Size frame_size = video_frame->coded_size();
+  if (size_type == SkCanvasVideoRenderer::ConvertingSize::VISUAL)
+    frame_size = video_frame->visible_rect().size();
+
   switch (video_frame->format()) {
     case PIXEL_FORMAT_YV12:
     case PIXEL_FORMAT_I420:
       if (CheckColorSpace(video_frame, COLOR_SPACE_JPEG)) {

[dshwang, 2016/10/18 19:14:36]

SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels() always use visual rect,
while coded rect can be bigger.
New VideoGLRendererPixelHiLoTest.SimpleYUVARect/1|3 reveals this existing bug.
VideoGLRendererPixelHiLoTest covers this change.

-        LIBYUV_J420_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
-                            video_frame->stride(VideoFrame::kYPlane),
-                            video_frame->visible_data(VideoFrame::kUPlane),
-                            video_frame->stride(VideoFrame::kUPlane),
-                            video_frame->visible_data(VideoFrame::kVPlane),
-                            video_frame->stride(VideoFrame::kVPlane),
-                            static_cast<uint8_t*>(rgb_pixels), row_bytes,
-                            video_frame->visible_rect().width(),
-                            video_frame->visible_rect().height());
+        LIBYUV_J420_TO_ARGB(
+            FrameData(video_frame, size_type, VideoFrame::kYPlane),
+            video_frame->stride(VideoFrame::kYPlane),
+            FrameData(video_frame, size_type, VideoFrame::kUPlane),
+            video_frame->stride(VideoFrame::kUPlane),
+            FrameData(video_frame, size_type, VideoFrame::kVPlane),
+            video_frame->stride(VideoFrame::kVPlane),
+            static_cast<uint8_t*>(rgb_pixels), row_bytes, frame_size.width(),
+            frame_size.height());
       } else if (CheckColorSpace(video_frame, COLOR_SPACE_HD_REC709)) {
-        LIBYUV_H420_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
-                            video_frame->stride(VideoFrame::kYPlane),
-                            video_frame->visible_data(VideoFrame::kUPlane),
-                            video_frame->stride(VideoFrame::kUPlane),
-                            video_frame->visible_data(VideoFrame::kVPlane),
-                            video_frame->stride(VideoFrame::kVPlane),
-                            static_cast<uint8_t*>(rgb_pixels), row_bytes,
-                            video_frame->visible_rect().width(),
-                            video_frame->visible_rect().height());
+        LIBYUV_H420_TO_ARGB(
+            FrameData(video_frame, size_type, VideoFrame::kYPlane),
+            video_frame->stride(VideoFrame::kYPlane),
+            FrameData(video_frame, size_type, VideoFrame::kUPlane),
+            video_frame->stride(VideoFrame::kUPlane),
+            FrameData(video_frame, size_type, VideoFrame::kVPlane),
+            video_frame->stride(VideoFrame::kVPlane),
+            static_cast<uint8_t*>(rgb_pixels), row_bytes, frame_size.width(),
+            frame_size.height());
       } else {
-        LIBYUV_I420_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
-                            video_frame->stride(VideoFrame::kYPlane),
-                            video_frame->visible_data(VideoFrame::kUPlane),
-                            video_frame->stride(VideoFrame::kUPlane),
-                            video_frame->visible_data(VideoFrame::kVPlane),
-                            video_frame->stride(VideoFrame::kVPlane),
-                            static_cast<uint8_t*>(rgb_pixels), row_bytes,
-                            video_frame->visible_rect().width(),
-                            video_frame->visible_rect().height());
+        LIBYUV_I420_TO_ARGB(
+            FrameData(video_frame, size_type, VideoFrame::kYPlane),
+            video_frame->stride(VideoFrame::kYPlane),
+            FrameData(video_frame, size_type, VideoFrame::kUPlane),
+            video_frame->stride(VideoFrame::kUPlane),
+            FrameData(video_frame, size_type, VideoFrame::kVPlane),
+            video_frame->stride(VideoFrame::kVPlane),
+            static_cast<uint8_t*>(rgb_pixels), row_bytes, frame_size.width(),
+            frame_size.height());
       }
       break;
     case PIXEL_FORMAT_YV16:
-      LIBYUV_I422_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
-                          video_frame->stride(VideoFrame::kYPlane),
-                          video_frame->visible_data(VideoFrame::kUPlane),
-                          video_frame->stride(VideoFrame::kUPlane),
-                          video_frame->visible_data(VideoFrame::kVPlane),
-                          video_frame->stride(VideoFrame::kVPlane),
-                          static_cast<uint8_t*>(rgb_pixels), row_bytes,
-                          video_frame->visible_rect().width(),
-                          video_frame->visible_rect().height());
+      LIBYUV_I422_TO_ARGB(
+          FrameData(video_frame, size_type, VideoFrame::kYPlane),
+          video_frame->stride(VideoFrame::kYPlane),
+          FrameData(video_frame, size_type, VideoFrame::kUPlane),
+          video_frame->stride(VideoFrame::kUPlane),
+          FrameData(video_frame, size_type, VideoFrame::kVPlane),
+          video_frame->stride(VideoFrame::kVPlane),
+          static_cast<uint8_t*>(rgb_pixels), row_bytes, frame_size.width(),
+          frame_size.height());
       break;
 
     case PIXEL_FORMAT_YV12A:
       LIBYUV_I420ALPHA_TO_ARGB(
-          video_frame->visible_data(VideoFrame::kYPlane),
+          FrameData(video_frame, size_type, VideoFrame::kYPlane),
           video_frame->stride(VideoFrame::kYPlane),
-          video_frame->visible_data(VideoFrame::kUPlane),
+          FrameData(video_frame, size_type, VideoFrame::kUPlane),
           video_frame->stride(VideoFrame::kUPlane),
-          video_frame->visible_data(VideoFrame::kVPlane),
+          FrameData(video_frame, size_type, VideoFrame::kVPlane),
           video_frame->stride(VideoFrame::kVPlane),
-          video_frame->visible_data(VideoFrame::kAPlane),
+          FrameData(video_frame, size_type, VideoFrame::kAPlane),
           video_frame->stride(VideoFrame::kAPlane),
-          static_cast<uint8_t*>(rgb_pixels), row_bytes,
-          video_frame->visible_rect().width(),
-          video_frame->visible_rect().height(),
+          static_cast<uint8_t*>(rgb_pixels), row_bytes, frame_size.width(),
+          frame_size.height(),
           1);  // 1 = enable RGB premultiplication by Alpha.
       break;
 
     case PIXEL_FORMAT_YV24:
-      LIBYUV_I444_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
-                          video_frame->stride(VideoFrame::kYPlane),
-                          video_frame->visible_data(VideoFrame::kUPlane),
-                          video_frame->stride(VideoFrame::kUPlane),
-                          video_frame->visible_data(VideoFrame::kVPlane),
-                          video_frame->stride(VideoFrame::kVPlane),
-                          static_cast<uint8_t*>(rgb_pixels), row_bytes,
-                          video_frame->visible_rect().width(),
-                          video_frame->visible_rect().height());
+      LIBYUV_I444_TO_ARGB(
+          FrameData(video_frame, size_type, VideoFrame::kYPlane),
+          video_frame->stride(VideoFrame::kYPlane),
+          FrameData(video_frame, size_type, VideoFrame::kUPlane),
+          video_frame->stride(VideoFrame::kUPlane),
+          FrameData(video_frame, size_type, VideoFrame::kVPlane),
+          video_frame->stride(VideoFrame::kVPlane),
+          static_cast<uint8_t*>(rgb_pixels), row_bytes, frame_size.width(),
+          frame_size.height());
       break;
 
     case PIXEL_FORMAT_YUV420P9:
     case PIXEL_FORMAT_YUV422P9:
     case PIXEL_FORMAT_YUV444P9:
     case PIXEL_FORMAT_YUV420P10:
     case PIXEL_FORMAT_YUV422P10:
     case PIXEL_FORMAT_YUV444P10:
     case PIXEL_FORMAT_YUV420P12:
     case PIXEL_FORMAT_YUV422P12:
     case PIXEL_FORMAT_YUV444P12: {
       scoped_refptr<VideoFrame> temporary_frame =
           DownShiftHighbitVideoFrame(video_frame);
-      ConvertVideoFrameToRGBPixels(temporary_frame.get(), rgb_pixels,
+      ConvertVideoFrameToRGBPixels(temporary_frame.get(), size_type, rgb_pixels,
                                    row_bytes);
       break;
     }
 
     case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_NV21:
     case PIXEL_FORMAT_UYVY:
     case PIXEL_FORMAT_YUY2:
     case PIXEL_FORMAT_ARGB:
     case PIXEL_FORMAT_XRGB:
@@ skipping 167 matching lines @@
       last_image_->bounds().contains(visible_rect)) {
     last_image_ = last_image_->makeSubset(visible_rect);
   }
 }
 
 SkISize SkCanvasVideoRenderer::LastImageDimensionsForTesting() {
   return last_image_dimensions_for_testing_;
 }
 
 }  // namespace media