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"
 #include "media/base/video_frame.h"
 #include "media/filters/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/size_conversions.h"
 
 const unsigned kYUVResourceFormat = GL_LUMINANCE;
 const unsigned kRGBResourceFormat = GL_RGBA;
 
 namespace cc {
 
-VideoFrameExternalResources::VideoFrameExternalResources()
-    : type(NONE), hardware_resource(0) {}
+VideoFrameExternalResources::VideoFrameExternalResources() : type(NONE) {}
 
 VideoFrameExternalResources::~VideoFrameExternalResources() {}
 
 VideoResourceUpdater::VideoResourceUpdater(ResourceProvider* resource_provider)
     : 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 170 matching lines @@
                        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) {
-  if (!VerifyFrame(video_frame))
-    return VideoFrameExternalResources();
-
   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();
   }
 
-  external_resources.hardware_resource =
-      resource_provider_->CreateResourceFromExternalTexture(
-          video_frame->texture_target(),
-          video_frame->texture_id());
+  // 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, video_frame);
 
-  TextureMailbox::ReleaseCallback callback_to_return_resource =
-      base::Bind(&ReturnTexture,
-                 base::Unretained(resource_provider_),
-                 external_resources.hardware_resource);
-  external_resources.hardware_release_callback = callback_to_return_resource;
+  external_resources.mailboxes.push_back(
+      TextureMailbox(video_frame->texture_mailbox(),
+                     callback_to_return_resource,
+                     video_frame->texture_target(),

[danakj, 2013/04/19 21:39:43]

Woops, I hadn't hooked the VideoFrame::texture_target() up. Now I get no GL
errors while playing HTML5 video on android and video shows up! \o/

+                     video_frame->texture_mailbox_sync_point()));
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::ReturnTexture(
-    ResourceProvider* resource_provider,
-    unsigned resource_id,
+    scoped_refptr<media::VideoFrame> video_frame,
     unsigned sync_point,
     bool lost_resource) {
-  resource_provider->DeleteResource(resource_id);
+    video_frame->set_texture_mailbox_sync_point(sync_point);
+
+  // 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