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

media/filters/skcanvas_video_renderer.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 "media/filters/skcanvas_video_renderer.h"
 
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_frame.h"
@@ skipping 185 matching lines @@
     SK_A32_SHIFT == 24
       libyuv::ARGBToABGR(static_cast<uint8*>(rgb_pixels),
                          row_bytes,
                          static_cast<uint8*>(rgb_pixels),
                          row_bytes,
                          video_frame->visible_rect().width(),
                          video_frame->visible_rect().height());
 #endif
       break;
 
-    case media::VideoFrame::NATIVE_TEXTURE: {
-      SkBitmap tmp;
-      tmp.installPixels(
-          SkImageInfo::MakeN32Premul(video_frame->visible_rect().width(),
-                                     video_frame->visible_rect().height()),
-          rgb_pixels,
-          row_bytes);
-      video_frame->ReadPixelsFromNativeTexture(tmp);

[dshwang, 2015/01/14 20:32:13]

Remove this complicated ReadPixel callback implementation in several files.

+    case media::VideoFrame::NATIVE_TEXTURE:
+      NOTREACHED();
       break;
-    }
-
     case media::VideoFrame::ARGB:
     default:
       NOTREACHED();
       break;
   }
 }
 
 bool IsSkBitmapProperlySizedTexture(const SkBitmap* bitmap,
                                     const gfx::Size& size) {
   return bitmap->getTexture() && bitmap->width() == size.width() &&
@@ skipping 42 matching lines @@
   }
 
   unsigned texture_id =
       static_cast<unsigned>((bitmap->getTexture())->getTextureHandle());
   // If CopyVideoFrameTextureToGLTexture() changes the state of the
   // |texture_id|, it's needed to invalidate the state cached in skia,
   // but currently the state isn't changed.
   SkCanvasVideoRenderer::CopyVideoFrameTextureToGLTexture(
       context_3d.gl, video_frame, texture_id, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       true, false);
+  bitmap->notifyPixelsChanged();
   return true;
 }
 
 class SyncPointClientImpl : public VideoFrame::SyncPointClient {
  public:
   explicit SyncPointClientImpl(gpu::gles2::GLES2Interface* gl) : gl_(gl) {}
   ~SyncPointClientImpl() override {}
   uint32 InsertSyncPoint() override { return gl_->InsertSyncPointCHROMIUM(); }
   void WaitSyncPoint(uint32 sync_point) override {
     gl_->WaitSyncPointCHROMIUM(sync_point);
@@ skipping 129 matching lines @@
   // Paint black rectangle if there isn't a frame available or the
   // frame has an unexpected format.
   if (!video_frame.get() || video_frame->natural_size().IsEmpty() ||
       !IsYUVOrNative(video_frame->format())) {
     canvas->drawRect(dest, paint);
     canvas->flush();
     return;
   }
 
   SkBitmap* target_frame = nullptr;
-  if (canvas->getGrContext()) {
+
+  if (video_frame->format() == VideoFrame::NATIVE_TEXTURE) {
+    // Draw HW Video on both SW and HW Canvas.
+    // In SW Canvas case, rely on skia drawing Ganesh SkBitmap on SW SkCanvas.

[dshwang, 2015/01/14 20:32:13]

As comment mentions, drawing ganesh SkBitmap on Sw SkCanvas is executed here,
which is in Blink thread.

     if (accelerated_last_frame_.isNull() ||
         video_frame->timestamp() != accelerated_last_frame_timestamp_) {
-      if (video_frame->format() == VideoFrame::NATIVE_TEXTURE) {
-        // Draw HW Video on HW Canvas.
-        DCHECK(context_3d.gl);
-        DCHECK(context_3d.gr_context);
-        if (accelerated_generator_) {
-          // Reset SkBitmap used in SWVideo-to-HWCanvas path.
-          accelerated_last_frame_.reset();
-          accelerated_generator_ = nullptr;
-        }
-        if (!CopyVideoFrameTextureToSkBitmapTexture(
-                video_frame.get(), &accelerated_last_frame_, context_3d)) {
-          NOTREACHED();
-          return;
-        }
-      } else {
+      DCHECK(context_3d.gl);
+      DCHECK(context_3d.gr_context);
+      if (accelerated_generator_) {
+        // Reset SkBitmap used in SWVideo-to-HWCanvas path.
+        accelerated_last_frame_.reset();
+        accelerated_generator_ = nullptr;
+      }
+      if (!CopyVideoFrameTextureToSkBitmapTexture(
+              video_frame.get(), &accelerated_last_frame_, context_3d)) {
+        NOTREACHED();
+        return;
+      }
+      DCHECK(video_frame->visible_rect().width() ==
+                 accelerated_last_frame_.width() &&
+             video_frame->visible_rect().height() ==
+                 accelerated_last_frame_.height());
+
+      accelerated_last_frame_timestamp_ = video_frame->timestamp();
+    }
+    target_frame = &accelerated_last_frame_;
+    accelerated_frame_deleting_timer_.Reset();
+  } else if (canvas->getGrContext()) {
+    DCHECK(video_frame->format() != VideoFrame::NATIVE_TEXTURE);
+    if (accelerated_last_frame_.isNull() ||
+        video_frame->timestamp() != accelerated_last_frame_timestamp_) {
+      {
         // Draw SW Video on HW Canvas.
         if (!accelerated_generator_ && !accelerated_last_frame_.isNull()) {
           // Reset SkBitmap used in HWVideo-to-HWCanvas path.
           accelerated_last_frame_.reset();
         }
         accelerated_generator_ = new VideoImageGenerator(video_frame);
 
         // Note: This takes ownership of |accelerated_generator_|.
         if (!SkInstallDiscardablePixelRef(accelerated_generator_,
                                           &accelerated_last_frame_)) {
           NOTREACHED();
           return;
         }
       }
       DCHECK(video_frame->visible_rect().width() ==
                  accelerated_last_frame_.width() &&
              video_frame->visible_rect().height() ==
                  accelerated_last_frame_.height());
 
       accelerated_last_frame_timestamp_ = video_frame->timestamp();
     } else if (accelerated_generator_) {
       accelerated_generator_->set_frame(video_frame);
     }
     target_frame = &accelerated_last_frame_;
     accelerated_frame_deleting_timer_.Reset();
   } else {
-    // Draw both SW and HW Video on SW Canvas.
+    // Draw SW Video on SW Canvas.
+    DCHECK(video_frame->format() != VideoFrame::NATIVE_TEXTURE);
     if (last_frame_.isNull() ||
         video_frame->timestamp() != last_frame_timestamp_) {
       // Check if |bitmap| needs to be (re)allocated.
       if (last_frame_.isNull() ||
           last_frame_.width() != video_frame->visible_rect().width() ||
           last_frame_.height() != video_frame->visible_rect().height()) {
         last_frame_.allocN32Pixels(video_frame->visible_rect().width(),
                                    video_frame->visible_rect().height());
         last_frame_.setIsVolatile(true);
       }
@@ skipping 52 matching lines @@
   if (need_transform)
     canvas->restore();
   canvas->flush();
   // SkCanvas::flush() causes the generator to generate SkImage, so delete
   // |video_frame| not to be outlived.
   if (canvas->getGrContext() && accelerated_generator_)
     accelerated_generator_->set_frame(nullptr);
 }
 
 void SkCanvasVideoRenderer::Copy(const scoped_refptr<VideoFrame>& video_frame,
-                                 SkCanvas* canvas) {
+                                 SkCanvas* canvas,
+                                 const Context3D& context_3d) {
   Paint(video_frame, canvas, video_frame->visible_rect(), 0xff,
-        SkXfermode::kSrc_Mode, media::VIDEO_ROTATION_0, Context3D());
+        SkXfermode::kSrc_Mode, media::VIDEO_ROTATION_0, context_3d);
 }
 
 // static
 void SkCanvasVideoRenderer::CopyVideoFrameTextureToGLTexture(
     gpu::gles2::GLES2Interface* gl,
     VideoFrame* video_frame,
     unsigned int texture,
     unsigned int level,
     unsigned int internal_format,
     unsigned int type,
@@ skipping 33 matching lines @@
   last_frame_timestamp_ = media::kNoTimestamp();
 }
 
 void SkCanvasVideoRenderer::ResetAcceleratedLastFrame() {
   accelerated_last_frame_.reset();
   accelerated_generator_ = nullptr;
   accelerated_last_frame_timestamp_ = media::kNoTimestamp();
 }
 
 }  // namespace media