Send hardware video frames with mailboxes.

cc/resources/video_resource_updater.cc

 // Copyright 2013 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/resources/video_resource_updater.h"
 
 #include "base/bind.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 16 matching lines @@
     : resource_provider_(resource_provider) {
 }
 
 VideoResourceUpdater::~VideoResourceUpdater() {
   while (!recycled_resources_.empty()) {
     resource_provider_->DeleteResource(recycled_resources_.back().resource_id);
     recycled_resources_.pop_back();
   }
 }
 
+VideoFrameExternalResources VideoResourceUpdater::
+    CreateExternalResourcesFromVideoFrame(
+        const scoped_refptr<media::VideoFrame>& video_frame) {
+  if (!VerifyFrame(video_frame))
+    return VideoFrameExternalResources();
+
+  if (video_frame->format() == media::VideoFrame::NATIVE_TEXTURE)
+    return CreateForHardwarePlanes(video_frame);
+  else
+    return CreateForSoftwarePlanes(video_frame);
+}
+
 bool VideoResourceUpdater::VerifyFrame(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   // If these fail, we'll have to add 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(video_frame->visible_rect().x(), 0);
   DCHECK_EQ(video_frame->visible_rect().y(), 0);
 
   switch (video_frame->format()) {
     // Acceptable inputs.
@@ skipping 43 matching lines @@
         NOTREACHED();
     }
   }
 
   DCHECK_EQ(output_resource_format, static_cast<unsigned>(kRGBResourceFormat));
   return coded_size;
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
     const scoped_refptr<media::VideoFrame>& video_frame) {
-  if (!VerifyFrame(video_frame))
-    return VideoFrameExternalResources();
-
   media::VideoFrame::Format input_frame_format = video_frame->format();
 
 #if defined(GOOGLE_TV)
   if (input_frame_format == media::VideoFrame::HOLE) {
     VideoFrameExternalResources external_resources;
     external_resources.type = VideoFrameExternalResources::HOLE;
     return external_resources;
   }
 #endif
 
@@ skipping 169 matching lines @@
         TextureMailbox(mailbox,
                        callback_to_free_resource,
                        plane_resources[i].sync_point));
   }
 
   external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
   return external_resources;
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
-    const scoped_refptr<media::VideoFrame>& video_frame,
-    const TextureMailbox::ReleaseCallback& release_callback) {
-  if (!VerifyFrame(video_frame))
-    return VideoFrameExternalResources();
-
+    const scoped_refptr<media::VideoFrame>& video_frame) {
   media::VideoFrame::Format frame_format = video_frame->format();
 
   DCHECK_EQ(frame_format, media::VideoFrame::NATIVE_TEXTURE);
   if (frame_format != media::VideoFrame::NATIVE_TEXTURE)
       return VideoFrameExternalResources();
 
   WebKit::WebGraphicsContext3D* context =
       resource_provider_->GraphicsContext3D();
   if (!context)
     return VideoFrameExternalResources();
 
   VideoFrameExternalResources external_resources;
   switch (video_frame->texture_target()) {
     case GL_TEXTURE_2D:
       external_resources.type = VideoFrameExternalResources::RGB_RESOURCE;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
       external_resources.type =
           VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE;
       break;
     case GL_TEXTURE_RECTANGLE_ARB:
       external_resources.type = VideoFrameExternalResources::IO_SURFACE;
       break;
     default:
       NOTREACHED();
       return VideoFrameExternalResources();
   }
 
-  gpu::Mailbox mailbox;
-  GLC(context, context->genMailboxCHROMIUM(mailbox.name));
-  GLC(context, context->bindTexture(GL_TEXTURE_2D, video_frame->texture_id()));
-  GLC(context, context->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name));
-  GLC(context, context->bindTexture(GL_TEXTURE_2D, 0));
-
+  // Hold a reference to the VideoFrame in the callback, so the frame stays
+  // alive while the texture is in use. As long as the frame is alive, the
+  // texture inside it will not be reused by the decoder.
   TextureMailbox::ReleaseCallback callback_to_return_resource =
       base::Bind(&ReturnTexture,
                  base::Unretained(resource_provider_),
-                 release_callback,
-                 video_frame->texture_id(),
-                 mailbox);
+                 video_frame);
   external_resources.mailboxes.push_back(
-      TextureMailbox(mailbox, callback_to_return_resource));
+      TextureMailbox(video_frame->texture_mailbox(),
+                     callback_to_return_resource));
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::ReturnTexture(
     ResourceProvider* resource_provider,
-    TextureMailbox::ReleaseCallback callback,
-    unsigned texture_id,
-    gpu::Mailbox mailbox,
+    scoped_refptr<media::VideoFrame> video_frame,
     unsigned sync_point,
     bool lost_resource) {
-  WebKit::WebGraphicsContext3D* context =
-      resource_provider->GraphicsContext3D();
-  GLC(context, context->bindTexture(GL_TEXTURE_2D, texture_id));
-  GLC(context, context->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name));
-  GLC(context, context->bindTexture(GL_TEXTURE_2D, 0));
-  callback.Run(sync_point, lost_resource);
+  if (sync_point) {
+    WebKit::WebGraphicsContext3D* context =
+        resource_provider->GraphicsContext3D();
+    GLC(context, context->waitSyncPoint(sync_point));

[piman, 2013/04/11 22:57:58]

You need to (shallow) flush here to ensure the video decoder context processing
of the mailbox will be ordered wrt the wait.

Alternative is to pass the sync point all the way to the
RendererGpuVideoDecoderFactories so that it waits just before the consume. It's
the usual pattern, but in this case since you know both contexts are in the same
channel, you don't technically need that - up to you.

+  }
+
+  // Dropping the reference to VideoFrame here releases the texture back to the
+  // decoder.
 }
 
 // static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     ResourceProvider* resource_provider,
     RecycleResourceData data,
     unsigned sync_point,
     bool lost_resource) {
   WebKit::WebGraphicsContext3D* context =
@@ skipping 24 matching lines @@
   }
 
   PlaneResource recycled_resource(data.resource_id,
                                   data.resource_size,
                                   data.resource_format,
                                   sync_point);
   updater->recycled_resources_.push_back(recycled_resource);
 }
 
 }  // namespace cc