Revert of Reland "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(), SkCanvasVideoRenderer::ConvertingSize::VISUAL, pixels,
-        row_bytes);
+    SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(frame_.get(), 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 275 matching lines @@
       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);
-}
-
 // We take the upper 8 bits of 16-bit data and convert it as luminance to ARGB.
 // We loose the precision here, but it is important not to render Y16 as RG_88.
 // To get the full precision use float textures with WebGL1 and e.g. R16UI or
 // R32F textures with WebGL2.
 void ConvertY16ToARGB(const VideoFrame* video_frame,
-                      SkCanvasVideoRenderer::ConvertingSize size_type,
                       void* argb_pixels,
                       size_t argb_row_bytes) {
-  const uint8_t* row_head =
-      FrameData(video_frame, size_type, VideoFrame::kYPlane);
+  const uint8_t* row_head = video_frame->visible_data(0);
   uint8_t* out = static_cast<uint8_t*>(argb_pixels);
   const size_t stride = video_frame->stride(0);
-  gfx::Size frame_size = video_frame->coded_size();
-  if (size_type == SkCanvasVideoRenderer::ConvertingSize::VISUAL)
-    frame_size = video_frame->visible_rect().size();
-  for (int i = 0; i < frame_size.height(); ++i) {
+  for (int i = 0; i < video_frame->visible_rect().height(); ++i) {
     uint32_t* rgba = reinterpret_cast<uint32_t*>(out);
-    const uint8_t* row_end = row_head + frame_size.width() * 2;
+    const uint8_t* row_end = row_head + video_frame->visible_rect().width() * 2;
     for (const uint8_t* row = row_head; row < row_end; ++row) {
       uint32_t gray_value = *++row;
       *rgba++ = SkColorSetRGB(gray_value, gray_value, gray_value);
     }
     out += argb_row_bytes;
     row_head += stride;
   }
 }
 
-}  // namespace
+}  // anonymous 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;
   }
 
-  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)) {
-        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());
+        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());
       } else if (CheckColorSpace(video_frame, COLOR_SPACE_HD_REC709)) {
-        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());
+        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());
       } else {
-        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());
+        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());
       }
       break;
     case PIXEL_FORMAT_YV16:
-      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());
+      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());
       break;
 
     case PIXEL_FORMAT_YV12A:
       LIBYUV_I420ALPHA_TO_ARGB(
-          FrameData(video_frame, size_type, VideoFrame::kYPlane),
+          video_frame->visible_data(VideoFrame::kYPlane),
           video_frame->stride(VideoFrame::kYPlane),
-          FrameData(video_frame, size_type, VideoFrame::kUPlane),
+          video_frame->visible_data(VideoFrame::kUPlane),
           video_frame->stride(VideoFrame::kUPlane),
-          FrameData(video_frame, size_type, VideoFrame::kVPlane),
+          video_frame->visible_data(VideoFrame::kVPlane),
           video_frame->stride(VideoFrame::kVPlane),
-          FrameData(video_frame, size_type, VideoFrame::kAPlane),
+          video_frame->visible_data(VideoFrame::kAPlane),
           video_frame->stride(VideoFrame::kAPlane),
-          static_cast<uint8_t*>(rgb_pixels), row_bytes, frame_size.width(),
-          frame_size.height(),
+          static_cast<uint8_t*>(rgb_pixels), row_bytes,
+          video_frame->visible_rect().width(),
+          video_frame->visible_rect().height(),
           1);  // 1 = enable RGB premultiplication by Alpha.
       break;
 
     case PIXEL_FORMAT_YV24:
-      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());
+      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());
       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(), size_type, rgb_pixels,
+      ConvertVideoFrameToRGBPixels(temporary_frame.get(), rgb_pixels,
                                    row_bytes);
       break;
     }
 
     case PIXEL_FORMAT_Y16:
-      ConvertY16ToARGB(video_frame, size_type, rgb_pixels, row_bytes);
+      ConvertY16ToARGB(video_frame, 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:
     case PIXEL_FORMAT_RGB24:
     case PIXEL_FORMAT_RGB32:
@@ skipping 160 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