Change paused frame of WebMediaPlayerMS from YV12 to I420

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 <string>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/video_frame_provider.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/blink/webgraphicscontext3d_impl.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_rotation.h"
-#include "media/base/video_util.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.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/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/public/web/WebView.h"
+#include "third_party/libyuv/include/libyuv/convert.h"
+#include "third_party/libyuv/include/libyuv/video_common.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 |frame| to a new YV12 media::VideoFrame.
-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);
     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::ConvertToI420(reinterpret_cast<uint8*>(bitmap.getPixels()),

[fbarchard, 2015/10/14 06:47:36]

Consider calling ARGBToI420.

ConvertToI420 expects a contiguous buffer, where bytes per row is 4 * width.
The original function media::CopyRGBToVideoFrame took bitmap.rowBytes(),
allowing for row padding.
ARGBToI420 takes rowbytes:

// Convert ARGB To I420.
LIBYUV_API
int ARGBToI420(const uint8* src_argb, int src_stride_argb,
               uint8* dst_y, int dst_stride_y,
               uint8* dst_u, int dst_stride_u,
               uint8* dst_v, int dst_stride_v,
               int width, int height);  

[emircan, 2015/10/14 21:02:32]

Done.

+                          bitmap.getSize(),
+                          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),
+                          0 /* crop_x */,
+                          0 /* crop_y */,
+                          bitmap.dimensions().fWidth,
+                          bitmap.dimensions().fHeight,
+                          size.width(), size.height(),
+                          libyuv::kRotate0, libyuv::FOURCC_ARGB);

[fbarchard, 2015/10/14 06:47:36]

Most code in media expects ABGR for Android.  Can you confirm this instance
always wants ARGB?

[emircan, 2015/10/14 21:02:32]

Sorry, I couldn't understand what you mean there. Can you elaborate?

We want output to be I420. It boils down to
VideoResourceUpdater::CreateForSoftwarePlanes() for compositing.

AFAIK, the input is RGB32. The earlier function used there was an RGB32
conversion. SKBitmap outputs ARGB as well.

[fbarchard, 2015/10/15 17:43:26]

In media/blink/skcanvas_video_renderer.cc there are ifdefs like this:

// Skia internal format depends on a platform. On Android it is ABGR, on others
// it is ARGB.
#if SK_B32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_R32_SHIFT == 16 && \
    SK_A32_SHIFT == 24
#define LIBYUV_I420_TO_ARGB libyuv::I420ToARGB
#else
#define LIBYUV_I420_TO_ARGB libyuv::I420ToABGR
..
So I just wanted to check that you are sure, on Android, that you want the same
format as other platforms, which is ARGB.

In libyuv terminology, ARGB ordering follows fourcc.org/directx, where
ARGB is BGRA in memory, or ARGB in a register
ABGR is RGBA in memory
RGB24 is BGR in memory
RAW is RGB in memory
https://code.google.com/p/libyuv/wiki/Formats

   } else {
     DCHECK(frame->IsMappable());
     DCHECK(frame->format() == media::PIXEL_FORMAT_YV12 ||
            frame->format() == media::PIXEL_FORMAT_I420);
-    for (size_t i = 0; i < media::VideoFrame::NumPlanes(frame->format()); ++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
 
 WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
@@ skipping 621 matching lines @@
   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.
   scoped_refptr<media::VideoFrame> new_frame =
-      CopyFrameToYV12(current_frame_, renderer);
+      CopyFrameToI420(current_frame_, renderer);
 
   current_frame_ = new_frame;
 }
 
 gfx::Size WebMediaPlayerMS::Compositor::GetCurrentSize() {
   base::AutoLock auto_lock(current_frame_lock_);
   return current_frame_.get() ? current_frame_->natural_size() : gfx::Size();
 }
 
 base::TimeDelta WebMediaPlayerMS::Compositor::GetCurrentTime() {
@@ skipping 22 matching lines @@
 bool WebMediaPlayerMS::Compositor::GetAlgorithmEnabled() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return !!frame_pool_;
 }
 
 void WebMediaPlayerMS::Compositor::SetSerial(uint32 serial) {
   DCHECK(thread_checker_.CalledOnValidThread());
   serial_ = serial;
 }
 }  // namespace content