Implement out-of-band video compositing on Android: Step 1

webkit/media/android/webmediaplayer_android.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 "webkit/media/android/webmediaplayer_android.h"
 
+#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "media/base/android/media_player_bridge.h"
+#include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
 #include "webkit/media/android/stream_texture_factory_android.h"
 #include "webkit/media/android/webmediaplayer_manager_android.h"
 #include "webkit/media/webmediaplayer_util.h"
 #include "webkit/media/webvideoframe_impl.h"
 
 static const uint32 kGLTextureExternalOES = 0x8D65;
 
@@ skipping 16 matching lines @@
       main_loop_(MessageLoop::current()),
       pending_seek_(0),
       seeking_(false),
       did_loading_progress_(false),
       manager_(manager),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       is_playing_(false),
       needs_establish_peer_(true),
       has_size_info_(false),
-      stream_texture_factory_(factory) {
+      stream_texture_factory_(factory),
+      needs_external_surface_(false) {
   main_loop_->AddDestructionObserver(this);
   if (manager_)
     player_id_ = manager_->RegisterMediaPlayer(this);
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kAlwaysUseExternalVideoSurface)) {
+    SetNeedsExternalSurface(true);
+  }
   if (stream_texture_factory_.get()) {
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
     stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
     ReallocateVideoFrame();
   }
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   if (stream_id_)
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
@@ skipping 12 matching lines @@
   url_ = url;
 
   InitializeMediaPlayer(url_);
 }
 
 void WebMediaPlayerAndroid::cancelLoad() {
   NOTIMPLEMENTED();
 }
 
 void WebMediaPlayerAndroid::play() {
+  if (hasVideo() && needs_external_surface_) {
+    DCHECK(!needs_establish_peer_);
+    RequestExternalSurface();
+  }
   if (hasVideo() && needs_establish_peer_)
     EstablishSurfaceTexturePeer();
 
   PlayInternal();
   is_playing_ = true;
 }
 
 void WebMediaPlayerAndroid::pause() {
   PauseInternal();
   is_playing_ = false;
@@ skipping 280 matching lines @@
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
     stream_id_ = 0;
   }
 
   video_frame_.reset();
 
   manager_ = NULL;
 }
 
 void WebMediaPlayerAndroid::ReallocateVideoFrame() {
-  if (texture_id_) {
+  if (needs_external_surface_) {
+    // VideoFrame::CreateHoleFrame is only defined under GOOGLE_TV.
+#if defined(GOOGLE_TV)
+    if (!natural_size_.isEmpty())
+      video_frame_.reset(new WebVideoFrameImpl(VideoFrame::CreateHoleFrame(
+          natural_size_)));
+#else
+    NOTIMPLEMENTED() << "Hole punching not supported outside of Google TV";
+#endif
+  } else if (texture_id_) {
     video_frame_.reset(new WebVideoFrameImpl(VideoFrame::WrapNativeTexture(
         texture_id_, kGLTextureExternalOES, natural_size_,
         gfx::Rect(natural_size_), natural_size_, base::TimeDelta(),
         VideoFrame::ReadPixelsCB(),
         base::Closure())));
   }
 }
 
 WebVideoFrame* WebMediaPlayerAndroid::getCurrentFrame() {
   if (stream_texture_proxy_.get() && !stream_texture_proxy_->IsInitialized()
-      && stream_id_) {
+      && stream_id_ && !needs_external_surface_) {
     stream_texture_proxy_->Initialize(
         stream_id_, video_frame_->width(), video_frame_->height());
   }
 
   return video_frame_.get();
 }
 
 void WebMediaPlayerAndroid::putCurrentFrame(
     WebVideoFrame* web_video_frame) {
 }
@@ skipping 11 matching lines @@
 }
 
 void WebMediaPlayerAndroid::SetNeedsEstablishPeer(bool needs_establish_peer) {
   needs_establish_peer_ = needs_establish_peer;
 }
 
 void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
   is_playing_ = is_playing;
 }
 
+void WebMediaPlayerAndroid::SetNeedsExternalSurface(

[scherkus (not reviewing), 2013/03/07 00:09:13]

do you really need this method? it looks like you could inline it inside the
constructor

[wonsik, 2013/03/07 02:54:08]

I expect to have more criteria for using external surface to come (for example,
CDM protected media), and those conditions may not be detectable at the
constructor.

[scherkus (not reviewing), 2013/03/07 18:59:10]

Unless you have a CL ready to review that uses this method, I'd rather have you
introduce this method when you actually need it.

Not only is it hard to predict the future, but it also makes it easier for the
code reviewer to understand the change when you introduce the function along
with the code that uses it.

[wonsik, 2013/03/11 12:32:44]

Got it. Done.

+    bool needs_external_surface) {
+  needs_external_surface_ = needs_external_surface;
+  SetNeedsEstablishPeer(!needs_external_surface);
+  ReallocateVideoFrame();
+}
+
 }  // namespace webkit_media