Change paused frame of WebMediaPlayerMS from YV12 to I420

content/renderer/media/webmediaplayer_ms_compositor.cc

 // Copyright 2015 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_compositor.h"
 
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/single_thread_task_runner.h"
 #include "cc/blink/context_provider_web_context.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/blink/skcanvas_video_renderer.h"
 #include "media/filters/video_renderer_algorithm.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
+#include "third_party/libyuv/include/libyuv/convert.h"
+#include "third_party/libyuv/include/libyuv/video_common.h"
 
 namespace content {
 
 namespace {
 
-// This function copies |frame| to a new YV12 media::VideoFrame.
-// TODO: Consider using libyuv for better performance. see http://crbug/541728
-scoped_refptr<media::VideoFrame> CopyFrameToYV12(
+// This function copies |frame| to a new I420 media::VideoFrame.
+scoped_refptr<media::VideoFrame> CopyFrameToI420(
     const scoped_refptr<media::VideoFrame>& frame,
     media::SkCanvasVideoRenderer* video_renderer) {
   const scoped_refptr<media::VideoFrame> new_frame =
       media::VideoFrame::CreateFrame(media::PIXEL_FORMAT_YV12,
                                      frame->coded_size(), frame->visible_rect(),
                                      frame->natural_size(), frame->timestamp());
+  const gfx::Size& size = frame->coded_size();
 
   if (frame->HasTextures()) {
     DCHECK(frame->format() == media::PIXEL_FORMAT_ARGB ||
            frame->format() == media::PIXEL_FORMAT_XRGB ||
            frame->format() == media::PIXEL_FORMAT_I420 ||
            frame->format() == media::PIXEL_FORMAT_UYVY);
     SkBitmap bitmap;
     bitmap.allocN32Pixels(frame->visible_rect().width(),
                           frame->visible_rect().height());
     SkCanvas canvas(bitmap);
 
     cc::ContextProvider* const provider =
         RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
     if (provider) {
       const 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());
+    libyuv::ARGBToI420(reinterpret_cast<uint8*>(bitmap.getPixels()),
+                       bitmap.rowBytes(),
+                       new_frame->data(media::VideoFrame::kYPlane),
+                       new_frame->stride(media::VideoFrame::kYPlane),
+                       new_frame->data(media::VideoFrame::kUPlane),
+                       new_frame->stride(media::VideoFrame::kUPlane),
+                       new_frame->data(media::VideoFrame::kVPlane),
+                       new_frame->stride(media::VideoFrame::kVPlane),
+                       size.width(), size.height());
   } else {
     DCHECK(frame->IsMappable());
     DCHECK(frame->format() == media::PIXEL_FORMAT_YV12 ||
            frame->format() == media::PIXEL_FORMAT_I420);
-    const size_t num_planes = media::VideoFrame::NumPlanes(frame->format());
-    for (size_t i = 0; i < num_planes; ++i) {
-      media::CopyPlane(i, frame->data(i), frame->stride(i), frame->rows(i),
-                       new_frame.get());
-    }
+    libyuv::I420Copy(frame->data(media::VideoFrame::kYPlane),
+                     frame->stride(media::VideoFrame::kYPlane),
+                     frame->data(media::VideoFrame::kUPlane),
+                     frame->stride(media::VideoFrame::kUPlane),
+                     frame->data(media::VideoFrame::kVPlane),
+                     frame->stride(media::VideoFrame::kVPlane),
+                     new_frame->data(media::VideoFrame::kYPlane),
+                     new_frame->stride(media::VideoFrame::kYPlane),
+                     new_frame->data(media::VideoFrame::kUPlane),
+                     new_frame->stride(media::VideoFrame::kUPlane),
+                     new_frame->data(media::VideoFrame::kVPlane),
+                     new_frame->stride(media::VideoFrame::kVPlane),
+                     size.width(), size.height());
   }
   return new_frame;
 }
 
 }  // anonymous namespace
 
 WebMediaPlayerMSCompositor::WebMediaPlayerMSCompositor(
     const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
     const blink::WebURL& url)
     : compositor_task_runner_(compositor_task_runner),
@@ skipping 204 matching lines @@
     media::SkCanvasVideoRenderer* renderer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(current_frame_lock_);
   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.
-  current_frame_ = CopyFrameToYV12(current_frame_, renderer);
+  current_frame_ = CopyFrameToI420(current_frame_, renderer);
 }
 
 bool WebMediaPlayerMSCompositor::MapTimestampsToRenderTimeTicks(
     const std::vector<base::TimeDelta>& timestamps,
     std::vector<base::TimeTicks>* wall_clock_times) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread() ||
          thread_checker_.CalledOnValidThread());
   for (const base::TimeDelta& timestamp : timestamps) {
     DCHECK(timestamps_to_clock_times_.count(timestamp));
     wall_clock_times->push_back(timestamps_to_clock_times_[timestamp]);
@@ skipping 33 matching lines @@
 
 void WebMediaPlayerMSCompositor::SetCurrentFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   current_frame_lock_.AssertAcquired();
   if (!current_frame_used_by_compositor_)
     ++dropped_frame_count_;
   current_frame_used_by_compositor_ = false;
   current_frame_ = frame;
 }
 }