Upstream implementation for embedded video for WebMediaPlayerAndroid

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 <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "media/base/android/media_player_bridge.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCookieJar.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.h"
+#include "webkit/media/android/stream_texture_factory_android.h"
+#include "webkit/media/android/webmediaplayer_manager_android.h"
 #include "webkit/media/android/webmediaplayer_proxy_android.h"
 #include "webkit/media/webmediaplayer_util.h"
 #include "webkit/media/webvideoframe_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebMediaPlayerClient;
 using WebKit::WebMediaPlayer;
 using WebKit::WebRect;
 using WebKit::WebSize;
 using WebKit::WebTimeRanges;
 using WebKit::WebURL;
 using WebKit::WebVideoFrame;
 using media::MediaPlayerBridge;
 using media::VideoFrame;
 using webkit_media::WebVideoFrameImpl;
 
+// TODO(qinmin): Figure out where we should define this more appropriately
+#define GL_TEXTURE_EXTERNAL_OES 0x8D65
+
 namespace webkit_media {
 
 // Because we create the media player lazily on android, the duration of the
 // media is initially unknown to us. This makes the user unable to perform
 // seek. To solve this problem, we use a temporary duration of 100 seconds when
 // the duration is unknown. And we scale the seek position later when duration
 // is available.
 // TODO(qinmin): create a thread and use android MediaMetadataRetriever
 // class to extract the duration.
 static const float kTemporaryDuration = 100.0f;
 
 bool WebMediaPlayerAndroid::incognito_mode_ = false;
 
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     WebMediaPlayerClient* client,
-    WebKit::WebCookieJar* cookie_jar)
+    WebKit::WebCookieJar* cookie_jar,
+    webkit_media::WebMediaPlayerManagerAndroid* manager,
+    webkit_media::StreamTextureFactory* factory)
     : client_(client),
       buffered_(1u),
       video_frame_(new WebVideoFrameImpl(VideoFrame::CreateEmptyFrame())),
       proxy_(new WebMediaPlayerProxyAndroid(base::MessageLoopProxy::current(),
                                             AsWeakPtr())),
       prepared_(false),
       duration_(0),
       pending_seek_(0),
       seeking_(false),
       playback_completed_(false),
       buffered_bytes_(0),
       cookie_jar_(cookie_jar),
+      manager_(manager),
       pending_play_event_(false),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
-      ready_state_(WebMediaPlayer::ReadyStateHaveNothing) {
-  video_frame_.reset(new WebVideoFrameImpl(VideoFrame::CreateEmptyFrame()));
+      ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
+      texture_id_(0),
+      stream_id_(0),
+      needs_establish_peer_(true),
+      stream_texture_factory_(factory) {
+  player_id_ = manager_->RegisterMediaPlayer(this);
+  if (stream_texture_factory_.get())
+    stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   if (media_player_.get()) {
     media_player_->Stop();
+    media_player_->SetVideoSurface(NULL);
   }
+
+  manager_->UnregisterMediaPlayer(player_id_);
 }
 
 void WebMediaPlayerAndroid::InitIncognito(bool incognito_mode) {
   incognito_mode_ = incognito_mode;
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url) {
   url_ = url;
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
@@ skipping 338 matching lines @@
   network_state_ = state;
   client_->networkStateChanged();
 }
 
 void WebMediaPlayerAndroid::UpdateReadyState(
     WebMediaPlayer::ReadyState state) {
   ready_state_ = state;
   client_->readyStateChanged();
 }
 
+void WebMediaPlayerAndroid::ReleaseMediaResources() {
+  // Pause the media player first.
+  pause();
+  client_->playbackStateChanged();
+
+  if (media_player_.get()) {
+    // Save the current media player status.
+    pending_seek_ = currentTime();
+    duration_ = duration();
+
+    // Disconnecting the Surface from the producer side allows
+    // all buffers but the one current (to the client) to be freed.
+    // We intentionally keep the current texture so we have something
+    // to show in the video layer.
+    // At the same time we happily avoid recreating the Surface to
+    // not have to deal with rewiring any proxies receiving notifications.
+    media_player_->SetVideoSurface(NULL);
+    media_player_.reset();
+    needs_establish_peer_ = true;
+  }
+  prepared_ = false;
+}
+
 void WebMediaPlayerAndroid::SetVideoSurface(jobject j_surface) {
   if (media_player_.get())
     media_player_->SetVideoSurface(j_surface);
 }
 
 void WebMediaPlayerAndroid::InitializeMediaPlayer() {
   CHECK(!media_player_.get());
   prepared_ = false;
   media_player_.reset(new MediaPlayerBridge());

[scherkus (not reviewing), 2012/05/25 22:01:46]

if a media_player_ existed... would we want to call SetVideoSurface(NULL) here?

Should ~MediaPlayerBridge dtor automatically call SetVideoSurface(NULL) or are
there cases where we don't want it to release it's video surface?

It scares me knowing that if we forget to call SVS(NULL) before deleting
media_player_ that we'll cause a performance regression!

[qinmin, 2012/05/26 00:37:42]

Moved SetVideoSurface(NULL) to MediaPlayerBridge dtor.

On 2012/05/25 22:01:46, scherkus wrote:

   media_player_->SetStayAwakeWhilePlaying();
 
   std::string cookies;
   if (cookie_jar_ != NULL) {
     WebURL url(url_);
     cookies = UTF16ToUTF8(cookie_jar_->cookies(url, url));
   }
   media_player_->SetDataSource(url_.spec(), cookies, incognito_mode_);
 
   media_player_->Prepare(
       base::Bind(&WebMediaPlayerProxyAndroid::MediaInfoCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::MediaErrorCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::VideoSizeChangedCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::BufferingUpdateCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::MediaPreparedCallback, proxy_));
 }
 
 void WebMediaPlayerAndroid::PlayInternal() {
   CHECK(prepared_);
 
+  if (hasVideo() && stream_texture_factory_.get()) {
+    if (!stream_id_)
+      CreateStreamTexture();
+
+    if (needs_establish_peer_) {
+      stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
+      needs_establish_peer_ = false;
+    }
+  }
+
   if (paused())
     media_player_->Start(base::Bind(
         &WebMediaPlayerProxyAndroid::PlaybackCompleteCallback, proxy_));
 }
 
 void WebMediaPlayerAndroid::PauseInternal() {
   CHECK(prepared_);
   media_player_->Pause();
 }
 
 void WebMediaPlayerAndroid::SeekInternal(float seconds) {
   CHECK(prepared_);
   seeking_ = true;
   media_player_->SeekTo(ConvertSecondsToTimestamp(seconds), base::Bind(
       &WebMediaPlayerProxyAndroid::SeekCompleteCallback, proxy_));
 }
 
+void WebMediaPlayerAndroid::CreateStreamTexture() {
+  DCHECK(!stream_id_);
+  DCHECK(!texture_id_);
+  stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
+  if (texture_id_)
+    video_frame_.reset(new WebVideoFrameImpl(VideoFrame::WrapNativeTexture(
+        texture_id_,
+        GL_TEXTURE_EXTERNAL_OES,
+        texture_size_.width,
+        texture_size_.height,
+        base::TimeDelta(),
+        base::TimeDelta(),
+        base::Bind(&WebMediaPlayerAndroid::DestroyStreamTexture,
+                   base::Unretained(this)))));
+}
+
+void WebMediaPlayerAndroid::DestroyStreamTexture() {
+  DCHECK(stream_id_);
+  DCHECK(texture_id_);
+  stream_texture_factory_->DestroyStreamTexture(texture_id_);
+  texture_id_ = 0;
+  stream_id_ = 0;
+}
+
 WebVideoFrame* WebMediaPlayerAndroid::getCurrentFrame() {
+  if (!stream_texture_proxy_->IsInitialized() && stream_id_) {
+    stream_texture_proxy_->Initialize(
+        stream_id_, video_frame_->width(), video_frame_->height());
+  }
+
   return video_frame_.get();
 }
 
 void WebMediaPlayerAndroid::putCurrentFrame(
     WebVideoFrame* web_video_frame) {
 }
 
+// This gets called both on compositor and main thread.
+void WebMediaPlayerAndroid::setStreamTextureClient(
+    WebKit::WebStreamTextureClient* client) {
+  if (stream_texture_proxy_.get())
+    stream_texture_proxy_->SetClient(client);
+}
+
 }  // namespace webkit_media