Implement "hole" video frame.

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 "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"
 
+#if defined(GOOGLE_TV)
+#include "cc/solid_color_draw_quad.h"
+#endif
+
 namespace cc {
 
 // static
 scoped_ptr<VideoLayerImpl> VideoLayerImpl::create(LayerTreeImpl* treeImpl, int id, VideoFrameProvider* provider)
 {
     scoped_ptr<VideoLayerImpl> layer(new VideoLayerImpl(treeImpl, id));
     layer->setProviderClientImpl(VideoFrameProviderClientImpl::Create(provider));
     DCHECK(treeImpl->proxy()->isImplThread());
     DCHECK(treeImpl->proxy()->isMainThreadBlocked());
     return layer.Pass();
@@ skipping 49 matching lines @@
 
 // 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:
         return GL_LUMINANCE;
     case media::VideoFrame::NATIVE_TEXTURE:
         return frame.texture_target();
+#if defined(GOOGLE_TV)
+    case media::VideoFrame::HOLE:
+        return GL_INVALID_VALUE;
+#endif
     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()) {
+#if defined(GOOGLE_TV)
+    case media::VideoFrame::HOLE:
+        return 0;
+#endif
     case media::VideoFrame::RGB32:
         return 1;
     case media::VideoFrame::YV12:
     case media::VideoFrame::YV16:
         return 3;
     case media::VideoFrame::INVALID:
     case media::VideoFrame::EMPTY:
     case media::VideoFrame::I420:
         break;
     case media::VideoFrame::NATIVE_TEXTURE:
@@ skipping 24 matching lines @@
         m_providerClientImpl->ReleaseLock();
 }
 
 void VideoLayerImpl::willDrawInternal(ResourceProvider* resourceProvider)
 {
     DCHECK(!m_externalTextureResource);
 
     if (!m_frame)
         return;
 
+#if defined(GOOGLE_TV)
+    if (m_frame->format() == media::VideoFrame::HOLE)
+        return;
+#endif
+
     m_format = convertVFCFormatToGLenum(*m_frame);
 
     // If these fail, we'll have to add draw logic that handles offset bitmap/
     // texture UVs.  For now, just expect (0, 0) offset, since all our decoders
     // so far don't offset.
     DCHECK_EQ(m_frame->visible_rect().x(), 0);
     DCHECK_EQ(m_frame->visible_rect().y(), 0);
 
     if (m_format == GL_INVALID_VALUE) {
         m_providerClientImpl->PutCurrentFrame(m_frame);
@@ skipping 43 matching lines @@
     gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
     gfx::Rect visibleRect = m_frame->visible_rect();
     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();
 
+#if defined(GOOGLE_TV)

[jamesr, 2013/02/26 07:31:35]

please put a comment in here below the #if defined() with a list of contact
email addresses for this code and explaining that this block is only maintained
by those people and not the general compositor team

[wonsik2, 2013/02/27 02:16:41]

Done.

+    if (m_frame->format() == media::VideoFrame::HOLE) {
+        scoped_ptr<SolidColorDrawQuad> solidColorDrawQuad = SolidColorDrawQuad::Create();
+        // Create a solid color quad with transparent black and force no
+        // blending.
+        solidColorDrawQuad->SetAll(sharedQuadState, quadRect, quadRect, quadRect, false, SK_ColorTRANSPARENT);
+        quadSink.append(solidColorDrawQuad.PassAs<DrawQuad>(), appendQuadsData);
+        return;
+    }
+#endif
+
     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);
@@ skipping 189 matching lines @@
 {
     m_providerClientImpl = providerClientImpl;
 }
 
 const char* VideoLayerImpl::layerTypeAsString() const
 {
     return "VideoLayer";
 }
 
 }  // namespace cc