Send hardware video frames with mailboxes.

content/renderer/media/renderer_gpu_video_decoder_factories.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 "content/renderer/media/renderer_gpu_video_decoder_factories.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include "base/bind.h"
@@ skipping 142 matching lines @@
 void RendererGpuVideoDecoderFactories::AsyncDeleteTexture(uint32 texture_id) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (!context_)
     return;
 
   gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
   gles2->DeleteTextures(1, &texture_id);
   DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
 }
 
+gpu::Mailbox RendererGpuVideoDecoderFactories::ProduceTextureToMailbox(
+    uint32 texture_id) {
+  gpu::Mailbox mailbox;
+  if (message_loop_->BelongsToCurrentThread()) {
+    AsyncProduceTextureToMailbox(texture_id, &mailbox);
+    return mailbox;
+  }
+
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &RendererGpuVideoDecoderFactories::AsyncProduceTextureToMailbox,
+      this,
+      texture_id,
+      &mailbox));
+  base::WaitableEvent* objects[] = {&aborted_waiter_, &async_waiter_};
+  base::WaitableEvent::WaitMany(objects, arraysize(objects));
+  return mailbox;
+}
+
+void RendererGpuVideoDecoderFactories::AsyncProduceTextureToMailbox(
+    uint32 texture_id, gpu::Mailbox* mailbox) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  if (!context_) {
+    async_waiter_.Signal();
+    return;
+  }
+
+  gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
+  gles2->GenMailboxCHROMIUM(mailbox->name);
+  gles2->BindTexture(GL_TEXTURE_2D, texture_id);
+  gles2->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox->name);

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

You probably need to shallow Flush so that the compositor context is properly
ordered wrt the Produce.
Alternatively, make a sync point and pass it through.

[danakj, 2013/04/12 00:01:39]

Should be fine to stick a sync point into the VideoFrame for the outgoing
mailbox.

The one coming back is trickier, the compositor doesn't have visibility into the
VideoFrame for the callback. Maybe the compositor just needs to replace the
sync_point in the video frame with its own, and then have the VideoFrame pass
its sync point in the release callback. I'll see how that looks.

+}
+
+void RendererGpuVideoDecoderFactories::ConsumeMailboxToTexture(
+    const gpu::Mailbox& mailbox, uint32 texture_id) {
+  if (message_loop_->BelongsToCurrentThread()) {
+    AsyncConsumeMailboxToTexture(mailbox, texture_id);
+    return;
+  }
+
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &RendererGpuVideoDecoderFactories::AsyncConsumeMailboxToTexture,
+      this,
+      mailbox,
+      texture_id));
+  base::WaitableEvent* objects[] = {&aborted_waiter_, &async_waiter_};
+  base::WaitableEvent::WaitMany(objects, arraysize(objects));
+}
+
+void RendererGpuVideoDecoderFactories::AsyncConsumeMailboxToTexture(
+    const gpu::Mailbox& mailbox, uint32 texture_id) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  if (!context_) {
+    async_waiter_.Signal();
+    return;
+  }
+
+  gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
+  gles2->BindTexture(GL_TEXTURE_2D, texture_id);
+  gles2->ConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+}
+
 void RendererGpuVideoDecoderFactories::ReadPixels(
     uint32 texture_id, uint32 texture_target, const gfx::Size& size,
     const SkBitmap& pixels) {
   // SkBitmaps use the SkPixelRef object to refcount the underlying pixels.
   // Multiple SkBitmaps can share a SkPixelRef instance. We use this to
   // ensure that the underlying pixels in the SkBitmap passed in remain valid
   // until the AsyncReadPixels() call completes.
   read_pixels_bitmap_.setPixelRef(pixels.pixelRef());
 
   if (!message_loop_->BelongsToCurrentThread()) {
@@ skipping 78 matching lines @@
   return aborted_waiter_.IsSignaled();
 }
 
 void RendererGpuVideoDecoderFactories::AsyncDestroyVideoDecodeAccelerator() {
   // OK to release because Destroy() will delete the VDA instance.
   if (vda_)
     vda_.release()->Destroy();
 }
 
 }  // namespace content