gpu video: optimize HW video to SW canvas and implement it for WebRTC.

content/renderer/media/webmediaplayer_ms.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_ms.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 21 matching lines @@
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using blink::WebCanvas;
 using blink::WebMediaPlayer;
 using blink::WebRect;
 using blink::WebSize;
 
+namespace content {
+
 namespace {
 
 // This function copies a YV12 or NATIVE_TEXTURE to a new YV12
 // media::VideoFrame.
 scoped_refptr<media::VideoFrame> CopyFrameToYV12(
-    const scoped_refptr<media::VideoFrame>& frame) {
+    const scoped_refptr<media::VideoFrame>& frame,
+    media::SkCanvasVideoRenderer* video_renderer) {
   DCHECK(frame->format() == media::VideoFrame::YV12 ||
          frame->format() == media::VideoFrame::I420 ||
          frame->format() == media::VideoFrame::NATIVE_TEXTURE);
   scoped_refptr<media::VideoFrame> new_frame =
       media::VideoFrame::CreateFrame(media::VideoFrame::YV12,
                                      frame->coded_size(),
                                      frame->visible_rect(),
                                      frame->natural_size(),
                                      frame->timestamp());
 
   if (frame->format() == media::VideoFrame::NATIVE_TEXTURE) {
     SkBitmap bitmap;
     bitmap.allocN32Pixels(frame->visible_rect().width(),
                           frame->visible_rect().height());
-    frame->ReadPixelsFromNativeTexture(bitmap);
+    SkCanvas canvas(bitmap);
 
+    cc::ContextProvider* provider =
+        RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
+    if (provider) {
+      media::Context3D context_3d =
+          media::Context3D(provider->ContextGL(), provider->GrContext());
+      DCHECK(context_3d.gl);
+      video_renderer->Copy(frame.get(), &canvas, context_3d);
+    } else {
+      // GPU Process crashed.
+      bitmap.eraseColor(SK_ColorTRANSPARENT);
+    }
     media::CopyRGBToVideoFrame(
         reinterpret_cast<uint8*>(bitmap.getPixels()),
         bitmap.rowBytes(),
         frame->visible_rect(),
         new_frame.get());
   } else {
     size_t number_of_planes =
         media::VideoFrame::NumPlanes(frame->format());
     for (size_t i = 0; i < number_of_planes; ++i) {
       media::CopyPlane(i, frame->data(i), frame->stride(i),
                        frame->rows(i), new_frame.get());
     }
   }
   return new_frame;
 }
 
 }  // anonymous namespace
 
-namespace content {
-
 WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
     media::MediaLog* media_log,
     scoped_ptr<MediaStreamRendererFactory> factory)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       buffered_(static_cast<size_t>(0)),
@@ skipping 119 matching lines @@
 
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PAUSE));
 
   if (!current_frame_.get())
     return;
 
   // Copy the frame so that rendering can show the last received frame.
   // The original frame must not be referenced when the player is paused since
   // there might be a finite number of available buffers. E.g, video that
   // originates from a video camera.
-  scoped_refptr<media::VideoFrame> new_frame = CopyFrameToYV12(current_frame_);
+  scoped_refptr<media::VideoFrame> new_frame =
+      CopyFrameToYV12(current_frame_, &video_renderer_);
+
   base::AutoLock auto_lock(current_frame_lock_);
   current_frame_ = new_frame;
 }
 
 bool WebMediaPlayerMS::supportsSave() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return false;
 }
 
 void WebMediaPlayerMS::seek(double seconds) {
@@ skipping 288 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 blink::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace content