Moved SkCanvasVideoRenderer to media/filters.

media/filters/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 "webkit/media/skcanvas_video_renderer.h"
+#include "media/filters/skcanvas_video_renderer.h"
 
 #include "base/logging.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
-namespace webkit_media {
+namespace media {
 
 static bool IsEitherYV12OrYV16(media::VideoFrame::Format format) {
   return format == media::VideoFrame::YV12 || format == media::VideoFrame::YV16;
 }
 
 static bool IsEitherYV12OrYV16OrNative(media::VideoFrame::Format format) {
   return IsEitherYV12OrYV16(format) ||
       format == media::VideoFrame::NATIVE_TEXTURE;
 }
 
 // CanFastPaint is a helper method to determine the conditions for fast
 // painting. The conditions are:
 // 1. No skew in canvas matrix.
 // 2. No flipping nor mirroring.
 // 3. Canvas has pixel format ARGB8888.
 // 4. Canvas is opaque.
 // 5. Frame format is YV12 or YV16.
 //
 // TODO(hclam): The fast paint method should support flipping and mirroring.
 // Disable the flipping and mirroring checks once we have it.
-static bool CanFastPaint(SkCanvas* canvas, const gfx::Rect& dest_rect,
-                         uint8_t alpha, media::VideoFrame::Format format) {
+static bool CanFastPaint(SkCanvas* canvas, uint8_t alpha,
+                         media::VideoFrame::Format format) {
   if (alpha != 0xFF || !IsEitherYV12OrYV16(format))
     return false;
 
   const SkMatrix& total_matrix = canvas->getTotalMatrix();
   // Perform the following checks here:
   // 1. Check for skewing factors of the transformation matrix. They should be
   //    zero.
   // 2. Check for mirroring and flipping. Make sure they are greater than zero.
   if (SkScalarNearlyZero(total_matrix.getSkewX()) &&
       SkScalarNearlyZero(total_matrix.getSkewY()) &&
       total_matrix.getScaleX() > 0 &&
       total_matrix.getScaleY() > 0) {
     SkDevice* device = canvas->getDevice();
     const SkBitmap::Config config = device->config();
 
     if (config == SkBitmap::kARGB_8888_Config && device->isOpaque()) {
       return true;
     }
   }
 
   return false;
 }
 
 // Fast paint does YUV => RGB, scaling, blitting all in one step into the
 // canvas. It's not always safe and appropriate to perform fast paint.
 // CanFastPaint() is used to determine the conditions.
 static void FastPaint(
     const scoped_refptr<media::VideoFrame>& video_frame,
     SkCanvas* canvas,
-    const gfx::Rect& dest_rect) {
+    const SkRect& dest_rect) {
   DCHECK(IsEitherYV12OrYV16(video_frame->format())) << video_frame->format();
   DCHECK_EQ(video_frame->stride(media::VideoFrame::kUPlane),
             video_frame->stride(media::VideoFrame::kVPlane));
 
   const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(true);
   media::YUVType yuv_type = (video_frame->format() == media::VideoFrame::YV12) ?
                             media::YV12 : media::YV16;
   int y_shift = yuv_type;  // 1 for YV12, 0 for YV16.
 
-  // Create a rectangle backed by SkScalar.
-  SkRect scalar_dest_rect;
-  scalar_dest_rect.iset(dest_rect.x(), dest_rect.y(),
-                        dest_rect.right(), dest_rect.bottom());
-
   // Transform the destination rectangle to local coordinates.
   const SkMatrix& local_matrix = canvas->getTotalMatrix();
   SkRect local_dest_rect;
-  local_matrix.mapRect(&local_dest_rect, scalar_dest_rect);
+  local_matrix.mapRect(&local_dest_rect, dest_rect);
 
   // After projecting the destination rectangle to local coordinates, round
   // the projected rectangle to integer values, this will give us pixel values
   // of the rectangle.
   SkIRect local_dest_irect, local_dest_irect_saved;
   local_dest_rect.round(&local_dest_irect);
   local_dest_rect.round(&local_dest_irect_saved);
 
   // No point painting if the destination rect doesn't intersect with the
   // clip rect.
@@ skipping 118 matching lines @@
 }
 
 SkCanvasVideoRenderer::SkCanvasVideoRenderer()
     : last_frame_timestamp_(media::kNoTimestamp()) {
 }
 
 SkCanvasVideoRenderer::~SkCanvasVideoRenderer() {}
 
 void SkCanvasVideoRenderer::Paint(media::VideoFrame* video_frame,
                                   SkCanvas* canvas,
-                                  const gfx::Rect& dest_rect,
+                                  const gfx::RectF& dest_rect,
                                   uint8_t alpha) {
   if (alpha == 0) {
     return;
   }
 
   SkRect dest;
-  dest.set(SkIntToScalar(dest_rect.x()), SkIntToScalar(dest_rect.y()),
-           SkIntToScalar(dest_rect.right()), SkIntToScalar(dest_rect.bottom()));
+  dest.set(dest_rect.x(), dest_rect.y(), dest_rect.right(), dest_rect.bottom());
 
   SkPaint paint;
   paint.setAlpha(alpha);
 
   // Paint black rectangle if there isn't a frame available or the
   // frame has an unexpected format.
   if (!video_frame || !IsEitherYV12OrYV16OrNative(video_frame->format())) {
     canvas->drawRect(dest, paint);
     return;
   }
 
   // Scale and convert to RGB in one step if we can.
-  if (CanFastPaint(canvas, dest_rect, alpha, video_frame->format())) {
-    FastPaint(video_frame, canvas, dest_rect);
+  if (CanFastPaint(canvas, alpha, video_frame->format())) {
+    FastPaint(video_frame, canvas, dest);
     return;
   }
 
   // Check if we should convert and update |last_frame_|.
   if (last_frame_.isNull() ||
       video_frame->GetTimestamp() != last_frame_timestamp_) {
     ConvertVideoFrameToBitmap(video_frame, &last_frame_);
     last_frame_timestamp_ = video_frame->GetTimestamp();
   }
 
   // Do a slower paint using |last_frame_|.
   paint.setFilterBitmap(true);
   canvas->drawBitmapRect(last_frame_, NULL, dest, &paint);
 }
 
-}  // namespace webkit_media
+}  // namespace media