Adding YUVA support for enabling Alpha Playback

cc/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/video_layer_impl.h"
 
 #include "base/logging.h"
 #include "cc/io_surface_draw_quad.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/renderer.h"
 #include "cc/resource_provider.h"
 #include "cc/stream_video_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/video_frame_provider_client_impl.h"
 #include "cc/yuv_video_draw_quad.h"
+#include "cc/yuva_video_draw_quad.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/filters/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 namespace cc {
 
 // static
 scoped_ptr<VideoLayerImpl> VideoLayerImpl::create(LayerTreeImpl* treeImpl, int id, VideoFrameProvider* provider)
 {
@@ skipping 51 matching lines @@
 {
     m_providerClientImpl->set_active_video_layer(this);
 }
 
 // Convert media::VideoFrame::Format to OpenGL enum values.
 static GLenum convertVFCFormatToGLenum(const media::VideoFrame& frame)
 {
     switch (frame.format()) {
     case media::VideoFrame::YV12:
     case media::VideoFrame::YV16:
+    case media::VideoFrame::YV12A:
         return GL_LUMINANCE;
     case media::VideoFrame::NATIVE_TEXTURE:
         return frame.texture_target();
     case media::VideoFrame::INVALID:
     case media::VideoFrame::RGB32:
     case media::VideoFrame::EMPTY:
     case media::VideoFrame::I420:
         NOTREACHED();
         break;
     }
     return GL_INVALID_VALUE;
 }
 
 size_t VideoLayerImpl::numPlanes() const
 {
     if (!m_frame)
         return 0;
 
     if (m_convertYUV)
         return 1;
 
     switch (m_frame->format()) {
     case media::VideoFrame::RGB32:
         return 1;
     case media::VideoFrame::YV12:
     case media::VideoFrame::YV16:
         return 3;
+    case media::VideoFrame::YV12A:
+        return 4;
     case media::VideoFrame::INVALID:
     case media::VideoFrame::EMPTY:
     case media::VideoFrame::I420:
         break;
     case media::VideoFrame::NATIVE_TEXTURE:
         return 0;
     }
     NOTREACHED();
     return 0;
 }
@@ skipping 39 matching lines @@
         m_frame = 0;
         return;
     }
 
     // FIXME: 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.
     m_convertYUV = resourceProvider->defaultResourceType() == ResourceProvider::Bitmap &&
         (m_frame->format() == media::VideoFrame::YV12 ||
+         m_frame->format() == media::VideoFrame::YV12A ||
          m_frame->format() == media::VideoFrame::YV16);
 
     if (m_convertYUV)
         m_format = GL_RGBA;
 
     if (!allocatePlaneData(resourceProvider)) {
         m_providerClientImpl->PutCurrentFrame(m_frame);
         m_frame = 0;
         return;
     }
@@ skipping 25 matching lines @@
     gfx::Size codedSize = m_frame->coded_size();
 
     // pixels for macroblocked formats.
     const float texWidthScale =
         static_cast<float>(visibleRect.width()) / codedSize.width();
     const float texHeightScale =
         static_cast<float>(visibleRect.height()) / codedSize.height();
 
     switch (m_format) {
     case GL_LUMINANCE: {
-        // YUV software decoder.
-        const FramePlane& yPlane = m_framePlanes[media::VideoFrame::kYPlane];
-        const FramePlane& uPlane = m_framePlanes[media::VideoFrame::kUPlane];
-        const FramePlane& vPlane = m_framePlanes[media::VideoFrame::kVPlane];
-        gfx::SizeF texScale(texWidthScale, texHeightScale);
-        scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::Create();
-        yuvVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane);
-        quadSink.append(yuvVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
+        if(m_frame->HasAlpha()) {
+            // YUVA software decoder.
+            const FramePlane& yPlane = m_framePlanes[media::VideoFrame::kYPlane];

[fgalligan1, 2013/02/12 01:20:58]

You can move yPlane, uPlave, vPlane, and texScale up one scope.

[vigneshv, 2013/02/15 18:05:02]

Done.

+            const FramePlane& uPlane = m_framePlanes[media::VideoFrame::kUPlane];
+            const FramePlane& vPlane = m_framePlanes[media::VideoFrame::kVPlane];
+            const FramePlane& aPlane = m_framePlanes[media::VideoFrame::kAPlane];
+            gfx::SizeF texScale(texWidthScale, texHeightScale);
+            scoped_ptr<YUVAVideoDrawQuad> yuvaVideoQuad = YUVAVideoDrawQuad::Create();
+            yuvaVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane, aPlane);
+            quadSink.append(yuvaVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
+        } else {
+            // YUV software decoder.
+            const FramePlane& yPlane = m_framePlanes[media::VideoFrame::kYPlane];
+            const FramePlane& uPlane = m_framePlanes[media::VideoFrame::kUPlane];
+            const FramePlane& vPlane = m_framePlanes[media::VideoFrame::kVPlane];
+            gfx::SizeF texScale(texWidthScale, texHeightScale);
+            scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::Create();
+            yuvVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane);
+            quadSink.append(yuvVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
+        }
+
         break;
     }
     case GL_RGBA: {
         // RGBA software decoder.
         const FramePlane& plane = m_framePlanes[media::VideoFrame::kRGBPlane];
         bool premultipliedAlpha = true;
         gfx::PointF uvTopLeft(0.f, 0.f);
         gfx::PointF uvBottomRight(texWidthScale, texHeightScale);
         const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
         bool flipped = false;
@@ skipping 56 matching lines @@
     m_providerClientImpl->PutCurrentFrame(m_frame);
     m_frame = 0;
 
     m_providerClientImpl->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:
@@ skipping 102 matching lines @@
 {
     m_providerClientImpl = providerClientImpl;
 }
 
 const char* VideoLayerImpl::layerTypeAsString() const
 {
     return "VideoLayer";
 }
 
 }  // namespace cc