Chrome renderer support for YV16.

chrome/renderer/media/video_renderer_impl.cc

 // Copyright (c) 2009 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 "chrome/renderer/media/video_renderer_impl.h"
 #include "media/base/buffers.h"
 #include "media/base/yuv_convert.h"
 
 VideoRendererImpl::VideoRendererImpl(WebMediaPlayerImpl* delegate)
     : delegate_(delegate),
@@ skipping 91 matching lines @@
                                   skia::PlatformCanvas* canvas,
                                   const gfx::Rect& dest_rect) {
   // 1. Convert YUV frame to RGB.
   base::TimeDelta timestamp = video_frame->GetTimestamp();
   if (video_frame != last_converted_frame_ ||
       timestamp != last_converted_timestamp_) {
     last_converted_frame_ = video_frame;
     last_converted_timestamp_ = timestamp;
     media::VideoSurface frame_in;
     if (video_frame->Lock(&frame_in)) {
-      // TODO(hclam): Support more video formats than just YV12.
-      DCHECK(frame_in.format == media::VideoSurface::YV12);
+      DCHECK(frame_in.format == media::VideoSurface::YV12 ||
+             frame_in.format == media::VideoSurface::YV16);
       DCHECK(frame_in.strides[media::VideoSurface::kUPlane] ==
              frame_in.strides[media::VideoSurface::kVPlane]);
       DCHECK(frame_in.planes == media::VideoSurface::kNumYUVPlanes);
       bitmap_.lockPixels();
+      media::YUVType yuv_type = (frame_in.format == media::VideoSurface::YV12) ?
+                                media::YV12 : media::YV16;
       media::ConvertYUVToRGB32(frame_in.data[media::VideoSurface::kYPlane],
                                frame_in.data[media::VideoSurface::kUPlane],
                                frame_in.data[media::VideoSurface::kVPlane],
                                static_cast<uint8*>(bitmap_.getPixels()),
                                frame_in.width,
                                frame_in.height,
                                frame_in.strides[media::VideoSurface::kYPlane],
                                frame_in.strides[media::VideoSurface::kUPlane],
                                bitmap_.rowBytes(),
-                               media::YV12);
+                               yuv_type);
       bitmap_.unlockPixels();
       video_frame->Unlock();
     } else {
       NOTREACHED();
     }
   }
 
   // 2. Paint the bitmap to canvas.
   SkMatrix matrix;
   matrix.setTranslate(static_cast<SkScalar>(dest_rect.x()),
                       static_cast<SkScalar>(dest_rect.y()));
   if (dest_rect.width()  != video_size_.width() ||
       dest_rect.height() != video_size_.height()) {
     matrix.preScale(SkIntToScalar(dest_rect.width()) /
                     SkIntToScalar(video_size_.width()),
                     SkIntToScalar(dest_rect.height()) /
                     SkIntToScalar(video_size_.height()));
   }
   canvas->drawBitmapMatrix(bitmap_, matrix, NULL);
 }
 
 void VideoRendererImpl::FastPaint(media::VideoFrame* video_frame,
                                   skia::PlatformCanvas* canvas,
                                   const gfx::Rect& dest_rect) {
   media::VideoSurface frame_in;
   if (video_frame->Lock(&frame_in)) {
-    // TODO(hclam): Support more video formats than just YV12.
-    DCHECK(frame_in.format == media::VideoSurface::YV12);
+    DCHECK(frame_in.format == media::VideoSurface::YV12 ||
+           frame_in.format == media::VideoSurface::YV16);
     DCHECK(frame_in.strides[media::VideoSurface::kUPlane] ==
            frame_in.strides[media::VideoSurface::kVPlane]);
     DCHECK(frame_in.planes == media::VideoSurface::kNumYUVPlanes);
     const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(true);
+    media::YUVType yuv_type = (frame_in.format == media::VideoSurface::YV12) ?

[scherkus (not reviewing), 2009/05/28 01:35:15]

we really should consider consolidating these two sets of enums -- I'll add it
to tracker

[fbarchard, 2009/05/28 02:23:32]

it does stand out as weird.
My longer term plan is a high level yuv scaler with clipping that takes any
VideoSurface and converts/scales/clips/rotates to a 32 bit canvas.  With only 2
formats, its not that interesting.  It'll also be more interesting to have a
smart clipper when we do rotation/mirroring in chrome.

+                              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);
@@ skipping 39 matching lines @@
                                 local_dest_irect_saved.fLeft) *
                                frame_in.width / dest_rect.width();
       size_t frame_clip_top = (local_dest_irect.fTop -
                                local_dest_irect_saved.fTop) *
                               frame_in.height / dest_rect.height();
 
       // Use the "left" and "top" of the destination rect to locate the offset
       // in Y, U and V planes.
       size_t y_offset = frame_in.strides[media::VideoSurface::kYPlane] *
                         frame_clip_top + frame_clip_left;
-      // Since the format is YV12, there is one U, V value per 2x2 block, thus
-      // the math here.
-      // TODO(hclam): handle formats other than YV12.
-      size_t uv_offset = frame_in.strides[media::VideoSurface::kUPlane] *
-                         (frame_clip_top / 2) + frame_clip_left / 2;
+      // For format YV12, there is one U, V value per 2x2 block.
+      // For format YV16, there is one u, V value per 2x1 block.
+      size_t uv_offset = (frame_in.strides[media::VideoSurface::kUPlane] *
+                         (frame_clip_top >> y_shift)) +
+                         (frame_clip_left >> 1);
       uint8* frame_clip_y = frame_in.data[media::VideoSurface::kYPlane] +
                             y_offset;
       uint8* frame_clip_u = frame_in.data[media::VideoSurface::kUPlane] +
                             uv_offset;
       uint8* frame_clip_v = frame_in.data[media::VideoSurface::kVPlane] +
                             uv_offset;
       bitmap.lockPixels();
+
       // TODO(hclam): do rotation and mirroring here.
       media::ScaleYUVToRGB32(frame_clip_y,
                              frame_clip_u,
                              frame_clip_v,
                              dest_rect_pointer,
                              frame_clip_width,
                              frame_clip_height,
                              local_dest_irect.width(),
                              local_dest_irect.height(),
                              frame_in.strides[media::VideoSurface::kYPlane],
                              frame_in.strides[media::VideoSurface::kUPlane],
                              bitmap.rowBytes(),
-                             media::YV12,
+                             yuv_type,
                              media::ROTATE_0);
       bitmap.unlockPixels();
     }
     video_frame->Unlock();
   } else {
     NOTREACHED();
   }
 }
 
 void VideoRendererImpl::TransformToSkIRect(const SkMatrix& matrix,
                                            const gfx::Rect& src_rect,
                                            SkIRect* dest_rect) {
     // Transform destination rect to local coordinates.
     SkRect transformed_rect;
     SkRect skia_dest_rect;
     skia_dest_rect.iset(src_rect.x(), src_rect.y(),
                         src_rect.right(), src_rect.bottom());
     matrix.mapRect(&transformed_rect, skia_dest_rect);
     transformed_rect.round(dest_rect);
 }