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_proxy_initialized_(false),
+      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(0);
   }
+
+  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(Texture) 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 SurfaceTexture to
+    // not have to deal with rewiring any proxies receiving notifications.
+    media_player_->SetVideoSurface(0);
+    media_player_.reset(NULL);
+    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());
   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_ && !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(texture_id_ && stream_id_);
+  stream_texture_factory_->DestroyStreamTexture(texture_id_);
+  texture_id_ = 0;
+  stream_id_ = 0;
+}
+
 WebVideoFrame* WebMediaPlayerAndroid::getCurrentFrame() {
+  if (!stream_texture_proxy_initialized_ && stream_id_) {
+    stream_texture_proxy_->Initialize(
+        stream_id_, video_frame_->width(), video_frame_->height());
+    stream_texture_proxy_initialized_ = true;
+  }
+
   return video_frame_.get();
 }
 
 void WebMediaPlayerAndroid::putCurrentFrame(
     WebVideoFrame* web_video_frame) {
 }
 
+// This gets called both on impl and main thread.
+void WebMediaPlayerAndroid::setStreamTextureClient(
+    WebKit::WebStreamTextureClient* client) {
+  if (stream_texture_proxy_.get())
+    stream_texture_proxy_->SetClient(client);
+}
+
 }  // namespace webkit_media