Move conversion from YUV420 to YV12 in WebMediaPlayerMs

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 53 matching lines @@
     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;
 }
 
+// Empty method used for keeping a reference to the original media::VideoFrame
+// in OnFrameAvailable() if a color conversion between I420 and YV12 is needed.
+static void ReleaseOriginalFrame(
+    const scoped_refptr<media::VideoFrame>& frame) {
+}
+
 }  // anonymous namespace
 
 namespace content {
 
 WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     MediaStreamClient* media_stream_client,
     media::MediaLog* media_log)
@@ skipping 311 matching lines @@
   DVLOG(3) << "WebMediaPlayerMS::PutCurrentFrame";
   DCHECK(pending_repaint_);
   pending_repaint_ = false;
 }
 
 void WebMediaPlayerMS::OnFrameAvailable(
     const scoped_refptr<media::VideoFrame>& frame) {
   DVLOG(3) << "WebMediaPlayerMS::OnFrameAvailable";
   DCHECK(thread_checker_.CalledOnValidThread());
   ++total_frame_count_;
+
+  // Rendering do not support I420 but video capture use I420.
+  // The only difference between YV12 and I420 is the order of U and V plane.
+  // To solve that the I420 frame is simply wrapped in an YV12 video frame.
+  scoped_refptr<media::VideoFrame> yv12_frame = frame;

[perkj_chrome, 2014/03/27 09:25:39]

The incoming frame can be a texture as well- not necessarily I420. 

+  if (frame->format() == media::VideoFrame::I420) {
+    yv12_frame = media::VideoFrame::WrapExternalYuvData(
+        media::VideoFrame::YV12,
+        frame->coded_size(),
+        frame->visible_rect(),
+        frame->natural_size(),
+        frame->stride(media::VideoFrame::kYPlane),
+        frame->stride(media::VideoFrame::kUPlane),
+        frame->stride(media::VideoFrame::kVPlane),
+        frame->data(media::VideoFrame::kYPlane),
+        frame->data(media::VideoFrame::kUPlane),
+        frame->data(media::VideoFrame::kVPlane),
+        frame->GetTimestamp(),
+        base::Bind(&ReleaseOriginalFrame, frame));
+  }
+
   if (!received_first_frame_) {
     received_first_frame_ = true;
     {
       base::AutoLock auto_lock(current_frame_lock_);
       DCHECK(!current_frame_used_);
-      current_frame_ = frame;
+      current_frame_ = yv12_frame;
     }
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
     GetClient()->sizeChanged();
 
     if (video_frame_provider_.get() && GetClient()->needsWebLayerForVideo()) {
       video_weblayer_.reset(
           new webkit::WebLayerImpl(cc::VideoLayer::Create(this)));
       GetClient()->setWebLayer(video_weblayer_.get());
     }
   }
 
   // Do not update |current_frame_| when paused.
   if (paused_)
     return;
 
   if (!sequence_started_) {
     sequence_started_ = true;
-    start_time_ = frame->GetTimestamp();
+    start_time_ = yv12_frame->GetTimestamp();
   }
   bool size_changed = !current_frame_.get() ||
-                      current_frame_->natural_size() != frame->natural_size();
+      current_frame_->natural_size() != yv12_frame->natural_size();
 
   {
     base::AutoLock auto_lock(current_frame_lock_);
     if (!current_frame_used_ && current_frame_.get())
       ++dropped_frame_count_;
-    current_frame_ = frame;
-    current_time_ = frame->GetTimestamp() - start_time_;
+    current_frame_ = yv12_frame;
+    current_time_ = yv12_frame->GetTimestamp() - start_time_;
     current_frame_used_ = false;
   }
 
   if (size_changed)
     GetClient()->sizeChanged();
 
   GetClient()->repaint();
 }
 
 void WebMediaPlayerMS::RepaintInternal() {
@@ skipping 23 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 blink::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace content