media: Add support for playback of VP8 Alpha video streams

cc/layers/video_layer_impl.cc

 // Copyright 2011 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 "cc/layers/video_layer_impl.h"
 
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
@@ skipping 115 matching lines @@
     return;
   }
 
   // TODO: If we're in software compositing mode, we do the YUV -> RGB
   // conversion here. That involves an extra copy of each frame to a bitmap.
   // Obviously, this is suboptimal and should be addressed once ubercompositor
   // starts shaping up.
   convert_yuv_ =
       resource_provider->default_resource_type() == ResourceProvider::Bitmap &&
       (format_ == media::VideoFrame::YV12 ||
+       format_ == media::VideoFrame::YV12A ||
        format_ == media::VideoFrame::YV16);
 
   if (convert_yuv_)
     format_ = media::VideoFrame::RGB32;
 
   if (!SetupFramePlanes(resource_provider)) {
     provider_client_impl_->PutCurrentFrame(frame_);
     frame_ = NULL;
     return;
   }
@@ skipping 63 matching lines @@
       yuv_video_quad->SetNew(shared_quad_state,
                              quad_rect,
                              opaque_rect,
                              tex_scale,
                              y_plane,
                              u_plane,
                              v_plane);
       quad_sink->Append(yuv_video_quad.PassAs<DrawQuad>(), append_quads_data);
       break;
     }
+    case media::VideoFrame::YV12A: {
+      // YUV software decoder.
+      const FramePlane& y_plane = frame_planes_[media::VideoFrame::kYPlane];
+      const FramePlane& u_plane = frame_planes_[media::VideoFrame::kUPlane];
+      const FramePlane& v_plane = frame_planes_[media::VideoFrame::kVPlane];
+      const FramePlane& a_plane = frame_planes_[media::VideoFrame::kAPlane];
+      gfx::SizeF tex_scale(tex_width_scale, tex_height_scale);
+      scoped_ptr<YUVVideoDrawQuad> yuva_video_quad = YUVVideoDrawQuad::Create();
+      yuva_video_quad->SetNew(shared_quad_state,
+                              quad_rect,
+                              opaque_rect,
+                              tex_scale,
+                              y_plane,
+                              u_plane,
+                              v_plane,
+                              a_plane);
+      quad_sink->Append(yuva_video_quad.PassAs<DrawQuad>(), append_quads_data);
+      break;
+    }
     case media::VideoFrame::RGB32: {
       // RGBA software decoder: a converted YUV frame (see: convert_yuv_).
       const FramePlane& plane = frame_planes_[media::VideoFrame::kRGBPlane];
       bool premultiplied_alpha = true;
       gfx::PointF uv_top_left(0.f, 0.f);
       gfx::PointF uv_bottom_right(tex_width_scale, tex_height_scale);
       float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
       bool flipped = false;
       scoped_ptr<TextureDrawQuad> texture_quad = TextureDrawQuad::Create();
       texture_quad->SetNew(shared_quad_state,
@@ skipping 96 matching lines @@
   provider_client_impl_->PutCurrentFrame(frame_);
   frame_ = NULL;
 
   provider_client_impl_->ReleaseLock();
 }
 
 static gfx::Size VideoFrameDimension(media::VideoFrame* frame, int plane) {
   gfx::Size dimensions = frame->coded_size();
   switch (frame->format()) {
     case media::VideoFrame::YV12:
-      if (plane != media::VideoFrame::kYPlane) {
+    case media::VideoFrame::YV12A:
+      if (plane != media::VideoFrame::kYPlane &&
+          plane != media::VideoFrame::kAPlane) {
         dimensions.set_width(dimensions.width() / 2);
         dimensions.set_height(dimensions.height() / 2);
       }
       break;
     case media::VideoFrame::YV16:
       if (plane != media::VideoFrame::kYPlane)
         dimensions.set_width(dimensions.width() / 2);
       break;
     default:
       break;
@@ skipping 17 matching lines @@
 
   resource_provider->DeleteResource(resource_id);
   resource_id = 0;
 }
 
 // Convert media::VideoFrame::Format to OpenGL enum values.
 static GLenum ConvertVFCFormatToGLenum(const media::VideoFrame::Format format) {
   switch (format) {
     case media::VideoFrame::YV12:
     case media::VideoFrame::YV16:
+    case media::VideoFrame::YV12A:
       return GL_LUMINANCE;
     case media::VideoFrame::RGB32:
       return GL_RGBA;
     case media::VideoFrame::NATIVE_TEXTURE:
 #if defined(GOOGLE_TV)
     case media::VideoFrame::HOLE:
 #endif
     case media::VideoFrame::INVALID:
     case media::VideoFrame::EMPTY:
     case media::VideoFrame::I420:
@@ skipping 88 matching lines @@
 void VideoLayerImpl::SetProviderClientImpl(
     scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl) {
   provider_client_impl_ = provider_client_impl;
 }
 
 const char* VideoLayerImpl::LayerTypeAsString() const {
   return "VideoLayer";
 }
 
 }  // namespace cc