media: Optimize HW Video to 2D Canvas copy.

content/renderer/media/webmediaplayer_impl.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 "content/renderer/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 16 matching lines @@
 #include "content/renderer/media/crypto/encrypted_media_player_support.h"
 #include "content/renderer/media/render_media_log.h"
 #include "content/renderer/media/texttrack_impl.h"
 #include "content/renderer/media/webaudiosourceprovider_impl.h"
 #include "content/renderer/media/webinbandtexttrack_impl.h"
 #include "content/renderer/media/webmediaplayer_delegate.h"
 #include "content/renderer/media/webmediaplayer_params.h"
 #include "content/renderer/media/webmediaplayer_util.h"
 #include "content/renderer/media/webmediasource_impl.h"
 #include "content/renderer/render_thread_impl.h"
-#include "gpu/GLES2/gl2extchromium.h"
-#include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/filter_collection.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/text_renderer.h"
 #include "media/base/video_frame.h"
 #include "media/filters/audio_renderer_impl.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
 #include "media/filters/gpu_video_decoder.h"
 #include "media/filters/opus_audio_decoder.h"
 #include "media/filters/renderer_impl.h"
 #include "media/filters/video_renderer_impl.h"
 #include "media/filters/vpx_video_decoder.h"
 #include "third_party/WebKit/public/platform/WebMediaSource.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
+#include "webkit/common/gpu/context_provider_web_context.h"
+#include "webkit/common/gpu/webgraphicscontext3d_impl.h"
 
 using blink::WebCanvas;
 using blink::WebMediaPlayer;
 using blink::WebRect;
 using blink::WebSize;
 using blink::WebString;
 using media::PipelineStatus;
 
 namespace {
 
 // Limits the range of playback rate.
 //
 // TODO(kylep): Revisit these.
 //
 // Vista has substantially lower performance than XP or Windows7.  If you speed
 // up a video too much, it can't keep up, and rendering stops updating except on
 // the time bar. For really high speeds, audio becomes a bottleneck and we just
 // use up the data we have, which may not achieve the speed requested, but will
 // not crash the tab.
 //
 // A very slow speed, ie 0.00000001x, causes the machine to lock up. (It seems
 // like a busy loop). It gets unresponsive, although its not completely dead.
 //
 // Also our timers are not very accurate (especially for ogg), which becomes
 // evident at low speeds and on Vista. Since other speeds are risky and outside
 // the norms, we think 1/16x to 16x is a safe and useful range for now.
 const double kMinRate = 0.0625;
 const double kMaxRate = 16.0;
 
-class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
- public:
-  explicit SyncPointClientImpl(
-      blink::WebGraphicsContext3D* web_graphics_context)
-      : web_graphics_context_(web_graphics_context) {}
-  virtual ~SyncPointClientImpl() {}
-  virtual uint32 InsertSyncPoint() OVERRIDE {
-    return web_graphics_context_->insertSyncPoint();
-  }
-  virtual void WaitSyncPoint(uint32 sync_point) OVERRIDE {
-    web_graphics_context_->waitSyncPoint(sync_point);
-  }
-
- private:
-  blink::WebGraphicsContext3D* web_graphics_context_;
-};
-
 }  // namespace
 
 namespace content {
 
 class BufferedDataSourceHostImpl;
 
 #define COMPILE_ASSERT_MATCHING_ENUM(name) \
   COMPILE_ASSERT(static_cast<int>(WebMediaPlayer::CORSMode ## name) == \
                  static_cast<int>(BufferedResourceLoader::k ## name), \
                  mismatching_enums)
@@ skipping 387 matching lines @@
 
   // TODO(scherkus): Clarify paint() API contract to better understand when and
   // why it's being called. For example, today paint() is called when:
   //   - We haven't reached HAVE_CURRENT_DATA and need to paint black
   //   - We're painting to a canvas
   // See http://crbug.com/341225 http://crbug.com/342621 for details.
   scoped_refptr<media::VideoFrame> video_frame =
       GetCurrentFrameFromCompositor();
 
   gfx::Rect gfx_rect(rect);
-
+  scoped_refptr<cc::ContextProvider> context_provider =
+      RenderThreadImpl::current()->SharedMainThreadContextProvider();
+  media::SkCanvasVideoRenderer::Context3DProvider provider{
+      context_provider->ContextGL(), context_provider->GrContext()};
   skcanvas_video_renderer_.Paint(video_frame.get(),
                                  canvas,
                                  gfx_rect,
                                  alpha,
                                  mode,
-                                 pipeline_metadata_.video_rotation);
+                                 pipeline_metadata_.video_rotation,
+                                 &provider);
 }
 
 bool WebMediaPlayerImpl::hasSingleSecurityOrigin() const {
   if (data_source_)
     return data_source_->HasSingleOrigin();
   return true;
 }
 
 bool WebMediaPlayerImpl::didPassCORSAccessCheck() const {
   if (data_source_)
@@ skipping 39 matching lines @@
     unsigned int level,
     unsigned int internal_format,
     unsigned int type,
     bool premultiply_alpha,
     bool flip_y) {
   TRACE_EVENT0("media", "WebMediaPlayerImpl:copyVideoTextureToPlatformTexture");
 
   scoped_refptr<media::VideoFrame> video_frame =
       GetCurrentFrameFromCompositor();
 
-  if (!video_frame.get())
-    return false;
-  if (video_frame->format() != media::VideoFrame::NATIVE_TEXTURE)
+  if (!video_frame ||
+      video_frame->format() != media::VideoFrame::NATIVE_TEXTURE)
     return false;
 
-  const gpu::MailboxHolder* mailbox_holder = video_frame->mailbox_holder();
-  if (mailbox_holder->texture_target != GL_TEXTURE_2D)
-    return false;
-
-  web_graphics_context->waitSyncPoint(mailbox_holder->sync_point);
-  uint32 source_texture = web_graphics_context->createAndConsumeTextureCHROMIUM(
-      GL_TEXTURE_2D, mailbox_holder->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,
-                                            type);
-  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);
-  web_graphics_context->flush();
-
-  SyncPointClientImpl client(web_graphics_context);
-  video_frame->UpdateReleaseSyncPoint(&client);
+  // TODO(dshwang): need more elegant way to convert WebGraphicsContext3D to
+  // GLES2Interface.
+  gpu::gles2::GLES2Interface* gl =
+      static_cast<webkit::gpu::WebGraphicsContext3DImpl*>(web_graphics_context)
+          ->GetGLInterface();
+  skcanvas_video_renderer_.CopyVideoFrameToTexture(gl,
+                                                   video_frame.get(),
+                                                   texture,
+                                                   level,
+                                                   internal_format,
+                                                   type,
+                                                   premultiply_alpha,
+                                                   flip_y);
   return true;
 }
 
 WebMediaPlayer::MediaKeyException
 WebMediaPlayerImpl::generateKeyRequest(const WebString& key_system,
                                        const unsigned char* init_data,
                                        unsigned init_data_length) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   return encrypted_media_support_->GenerateKeyRequest(
@@ skipping 394 matching lines @@
   compositor_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&GetCurrentFrameAndSignal,
                                                base::Unretained(compositor_),
                                                &video_frame,
                                                &event));
   event.Wait();
   return video_frame;
 }
 
 }  // namespace content