media: Add support for playback of VP8 Alpha video streams

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 "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 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;
 }
 
+static bool IsEitherYV12OrYV12AOrYV16(media::VideoFrame::Format format) {
+  return IsEitherYV12OrYV16(format) ||
+      format == media::VideoFrame::YV12A;
+}
+
+static bool IsEitherYV12OrYV12AOrYV16OrNative(
+    media::VideoFrame::Format format) {
+  return IsEitherYV12OrYV16OrNative(format) ||
+      format == media::VideoFrame::YV12A;
+}
+
 // 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.
@@ skipping 27 matching lines @@
 // CanFastPaint() is used to determine the conditions.
 static void FastPaint(
     const scoped_refptr<media::VideoFrame>& video_frame,
     SkCanvas* canvas,
     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 = media::YV16;
+  media::YUVType yuv_type = video_frame->format() == media::VideoFrame::YV12 ||

[scherkus (not reviewing), 2013/02/27 07:28:26]

is this change required?

it seems like assigning media::YV12 to |yuv_type| is handled by the condition on
lines 86-90

[vignesh, 2013/03/28 21:45:12]

Done.

+                            video_frame->format() == media::VideoFrame::YV12A ?
+                                media::YV12 : media::YV16;
   int y_shift = 0;
-  if (video_frame->format() == media::VideoFrame::YV12) {
+  if (video_frame->format() == media::VideoFrame::YV12 ||
+      video_frame->format() == media::VideoFrame::YV12A) {
     yuv_type = media::YV12;
     y_shift = 1;
   }
 
   // Transform the destination rectangle to local coordinates.
   const SkMatrix& local_matrix = canvas->getTotalMatrix();
   SkRect local_dest_rect;
   local_matrix.mapRect(&local_dest_rect, dest_rect);
 
   // After projecting the destination rectangle to local coordinates, round
@@ skipping 79 matching lines @@
                          media::FILTER_BILINEAR);
   bitmap.unlockPixels();
 }
 
 // Converts a VideoFrame containing YUV data to a SkBitmap containing RGB data.
 //
 // |bitmap| will be (re)allocated to match the dimensions of |video_frame|.
 static void ConvertVideoFrameToBitmap(
     const scoped_refptr<media::VideoFrame>& video_frame,
     SkBitmap* bitmap) {
-  DCHECK(IsEitherYV12OrYV16OrNative(video_frame->format()))
+  DCHECK(IsEitherYV12OrYV12AOrYV16OrNative(video_frame->format()))
       << video_frame->format();
-  if (IsEitherYV12OrYV16(video_frame->format())) {
+  if (IsEitherYV12OrYV12AOrYV16(video_frame->format())) {
     DCHECK_EQ(video_frame->stride(media::VideoFrame::kUPlane),
               video_frame->stride(media::VideoFrame::kVPlane));
   }
 
   // Check if |bitmap| needs to be (re)allocated.
   if (bitmap->isNull() ||
       bitmap->width() != video_frame->visible_rect().width() ||
       bitmap->height() != video_frame->visible_rect().height()) {
     bitmap->setConfig(SkBitmap::kARGB_8888_Config,
                       video_frame->visible_rect().width(),
                       video_frame->visible_rect().height());
     bitmap->allocPixels();
     bitmap->setIsVolatile(true);
   }
 
   bitmap->lockPixels();
-  if (IsEitherYV12OrYV16(video_frame->format())) {
-    media::YUVType yuv_type = media::YV16;
+
+  media::YUVType yuv_type;
+  uint8* frame_clip_y;
+  uint8* frame_clip_u;
+  uint8* frame_clip_v;
+  if (IsEitherYV12OrYV12AOrYV16(video_frame->format())) {
+    yuv_type = media::YV16;
+
     int y_shift = 0;
-    if (video_frame->format() == media::VideoFrame::YV12) {
+    if (video_frame->format() == media::VideoFrame::YV12 ||
+        video_frame->format() == media::VideoFrame::YV12A) {
       yuv_type = media::YV12;
       y_shift = 1;
     }
 
     // Use the "left" and "top" of the destination rect to locate the offset
     // in Y, U and V planes.
     size_t y_offset = (video_frame->stride(media::VideoFrame::kYPlane) *
                        video_frame->visible_rect().y()) +
                       video_frame->visible_rect().x();
 
     // 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 = (video_frame->stride(media::VideoFrame::kUPlane) *
                         (video_frame->visible_rect().y() >> y_shift)) +
                        (video_frame->visible_rect().x() >> 1);
-    uint8* frame_clip_y =
-        video_frame->data(media::VideoFrame::kYPlane) + y_offset;
-    uint8* frame_clip_u =
-        video_frame->data(media::VideoFrame::kUPlane) + uv_offset;
-    uint8* frame_clip_v =
-        video_frame->data(media::VideoFrame::kVPlane) + uv_offset;
+    frame_clip_y = video_frame->data(media::VideoFrame::kYPlane) + y_offset;
+    frame_clip_u = video_frame->data(media::VideoFrame::kUPlane) + uv_offset;
+    frame_clip_v = video_frame->data(media::VideoFrame::kVPlane) + uv_offset;
+  }
+  switch (video_frame->format()) {
+    case media::VideoFrame::YV12:
+    case media::VideoFrame::YV16:

[scherkus (not reviewing), 2013/02/27 07:28:26]

I'm not a fan of duplicating the format checks and having uninitialized
frame_clip_{yuv} variables -- if this code shuffles around it'll be easy to
mismatch the conditions and introduce bugs / crashes


I think this code is pretty old and can be simplified. It seems to go out of its
way to avoid duplicating calls to ConvertYUVToRGB32() when in fact I think
duplicating those function calls would be clearer. For example, can we replace
the frame_clip_{yuv} values with calls to video_frame->data(...)?

Can you try converting to a switch w/ each format having its own call to
ConvertYUVToRGB32?

[vignesh, 2013/03/28 21:45:12]

Done.

+      media::ConvertYUVToRGB32(frame_clip_y,
+                               frame_clip_u,
+                               frame_clip_v,
+                               static_cast<uint8*>(bitmap->getPixels()),
+                               video_frame->visible_rect().width(),
+                               video_frame->visible_rect().height(),
+                               video_frame->stride(media::VideoFrame::kYPlane),
+                               video_frame->stride(media::VideoFrame::kUPlane),
+                               bitmap->rowBytes(),
+                               yuv_type);
+      break;
 
-    media::ConvertYUVToRGB32(frame_clip_y,
-                             frame_clip_u,
-                             frame_clip_v,
-                             static_cast<uint8*>(bitmap->getPixels()),
-                             video_frame->visible_rect().width(),
-                             video_frame->visible_rect().height(),
-                             video_frame->stride(media::VideoFrame::kYPlane),
-                             video_frame->stride(media::VideoFrame::kUPlane),
-                             bitmap->rowBytes(),
-                             yuv_type);
-  } else {
-    DCHECK_EQ(video_frame->format(), media::VideoFrame::NATIVE_TEXTURE);
-    video_frame->ReadPixelsFromNativeTexture(bitmap->getPixels());
+    case media::VideoFrame::YV12A:
+      media::ConvertYUVAToARGB(frame_clip_y,
+                               frame_clip_u,
+                               frame_clip_v,
+                               video_frame->data(media::VideoFrame::kAPlane),
+                               static_cast<uint8*>(bitmap->getPixels()),
+                               video_frame->visible_rect().width(),
+                               video_frame->visible_rect().height(),
+                               video_frame->stride(media::VideoFrame::kYPlane),
+                               video_frame->stride(media::VideoFrame::kUPlane),
+                               video_frame->stride(media::VideoFrame::kAPlane),
+                               bitmap->rowBytes(),
+                               media::YV12);
+      break;
+
+    case media::VideoFrame::NATIVE_TEXTURE:
+      DCHECK_EQ(video_frame->format(), media::VideoFrame::NATIVE_TEXTURE);
+      video_frame->ReadPixelsFromNativeTexture(bitmap->getPixels());
+      break;
+
+    default:
+      NOTREACHED();
+      break;
   }
   bitmap->notifyPixelsChanged();
   bitmap->unlockPixels();
 }
 
 SkCanvasVideoRenderer::SkCanvasVideoRenderer()
     : last_frame_timestamp_(media::kNoTimestamp()) {
 }
 
 SkCanvasVideoRenderer::~SkCanvasVideoRenderer() {}
 
 void SkCanvasVideoRenderer::Paint(media::VideoFrame* video_frame,
                                   SkCanvas* canvas,
                                   const gfx::RectF& dest_rect,
                                   uint8_t alpha) {
   if (alpha == 0) {
     return;
   }
 
   SkRect dest;
   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())) {
+  if (!video_frame ||
+      !IsEitherYV12OrYV12AOrYV16OrNative(video_frame->format())) {
     canvas->drawRect(dest, paint);
     return;
   }
 
   // Scale and convert to RGB in one step if we can.
   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 media