Send hardware video frames with mailboxes.

webkit/media/webmediaplayer_impl.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 "webkit/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 704 matching lines @@
 
 void WebMediaPlayerImpl::PutCurrentFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   if (!accelerated_compositing_reported_) {
     accelerated_compositing_reported_ = true;
     DCHECK(frame_->view()->isAcceleratedCompositingActive());
     UMA_HISTOGRAM_BOOLEAN("Media.AcceleratedCompositingActive", true);
   }
 }
 
 bool WebMediaPlayerImpl::copyVideoTextureToPlatformTexture(

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

Is this the same as the webgl thing for printing? I.e. do you need to wait for
refcounting + read-only sharing for this to land?

[danakj, 2013/04/11 23:49:08]

I think this should work fine now without ubercomp. It would break if you turned
on ubercomp without ref-counting landing first. Or is that a misunderstanding.
If that's true is it okay to land?

[piman, 2013/04/12 00:54:25]

As it is today, Produce/Consume is (locally) destructive, so  I'm going to ask
more questions:
1- is this called exclusively while the current frame is "owned" by the media
player side?
2- the locking seems insufficient, but I don't know the threading expectations.
What prevents another thread from consuming the mailbox too, at the same time?
3- don't you need to produce the texture again before deleting?

     WebKit::WebGraphicsContext3D* web_graphics_context,
     unsigned int texture,
     unsigned int level,
     unsigned int internal_format,
     bool premultiply_alpha,
     bool flip_y) {
   scoped_refptr<media::VideoFrame> video_frame;
   {
     base::AutoLock auto_lock(lock_);
     video_frame = current_frame_;
   }
   if (video_frame &&
       video_frame->format() == media::VideoFrame::NATIVE_TEXTURE &&
       video_frame->texture_target() == GL_TEXTURE_2D) {
-    uint32 source_texture = video_frame->texture_id();
+    uint32 source_texture = web_graphics_context->createTexture();
+
+    web_graphics_context->bindTexture(GL_TEXTURE_2D, source_texture);
+    const gpu::Mailbox& mailbox = video_frame->texture_mailbox();
+    web_graphics_context->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+
     // The video is stored in a unmultiplied format, so premultiply
     // if necessary.
     web_graphics_context->pixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM,
         premultiply_alpha);
     // Application itself needs to take care of setting the right flip_y
     // value down to get the expected result.
     // flip_y==true means to reverse the video orientation while
     // flip_y==false means to keep the intrinsic orientation.
     web_graphics_context->pixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
     web_graphics_context->copyTextureCHROMIUM(GL_TEXTURE_2D,
         source_texture, texture, level, internal_format);
     web_graphics_context->pixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, false);
     web_graphics_context->pixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM,
         false);
+
+    web_graphics_context->deleteTexture(source_texture);
+
     // The flush() operation is not necessary here. It is kept since the
     // performance will be better when it is added than not.
     web_graphics_context->flush();
     return true;
   }
   return false;
 }
 
 // Helper functions to report media EME related stats to UMA. They follow the
 // convention of more commonly used macros UMA_HISTOGRAM_ENUMERATION and
@@ skipping 501 matching lines @@
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace webkit_media