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 (!all_resources_.empty()) {
     resource_provider_->DeleteResource(all_resources_.back());
     all_resources_.pop_back();
   }
 }
 
 void VideoResourceUpdater::DeleteResource(unsigned resource_id) {
   resource_provider_->DeleteResource(resource_id);
   all_resources_.erase(std::remove(all_resources_.begin(),
                                    all_resources_.end(),
                                    resource_id));
 }
 
+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 45 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 181 matching lines @@
   if (!mailbox_success) {
     for (size_t i = 0; i < plane_resources.size(); ++i)
       DeleteResource(plane_resources[i].resource_id);
     return VideoFrameExternalResources();
   }
 
   external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
   return external_resources;
 }
 
+static void ReturnTexture(
+    scoped_refptr<media::VideoFrame::MailboxHolder> mailbox_holder,
+    unsigned sync_point,
+    bool lost_resource) {
+  mailbox_holder->Return(sync_point);
+}
+
 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());
-  if (external_resources.hardware_resource)
-    all_resources_.push_back(external_resources.hardware_resource);
+  scoped_refptr<media::VideoFrame::MailboxHolder> mailbox_holder =
+      video_frame->texture_mailbox();
 
   TextureMailbox::ReleaseCallback callback_to_return_resource =
-      base::Bind(&ReturnTexture,
-                 AsWeakPtr(),
-                 external_resources.hardware_resource);
-  external_resources.hardware_release_callback = callback_to_return_resource;
+      base::Bind(&ReturnTexture, mailbox_holder);
+
+  external_resources.mailboxes.push_back(
+      TextureMailbox(mailbox_holder->mailbox(),
+                     callback_to_return_resource,
+                     video_frame->texture_target(),
+                     mailbox_holder->sync_point()));
   return external_resources;
 }
 
 // static
-void VideoResourceUpdater::ReturnTexture(
-    base::WeakPtr<VideoResourceUpdater> updater,
-    unsigned resource_id,
-    unsigned sync_point,
-    bool lost_resource) {
-  if (!updater.get()) {
-    // Resource was already deleted.
-    return;
-  }
-
-  updater->DeleteResource(resource_id);
-}
-
-// static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     RecycleResourceData data,
     unsigned sync_point,
     bool lost_resource) {
   if (!updater.get()) {
     // Resource was already deleted.
     return;
   }
 
@@ 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