Implement WebRTC in Chrome for TV

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 "base/strings/string_number_conversions.h"
 #include "cc/layers/video_layer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/base/android/media_player_bridge.h"
 #include "media/base/video_frame.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/compositor_bindings/web_layer_impl.h"
 #include "webkit/media/android/webmediaplayer_manager_android.h"
 #include "webkit/media/android/webmediaplayer_proxy_android.h"
 #include "webkit/media/media_switches.h"
 #include "webkit/media/webmediaplayer_util.h"
 
 #if defined(GOOGLE_TV)
 #include "webkit/media/android/media_source_delegate.h"
+#include "webkit/media/media_stream_audio_renderer.h"
+#include "webkit/media/media_stream_client.h"
 #endif
 
 static const uint32 kGLTextureExternalOES = 0x8D65;
 
 using WebKit::WebMediaPlayer;
 using WebKit::WebMediaSource;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebTimeRanges;
 using WebKit::WebURL;
 using media::MediaPlayerBridge;
 using media::VideoFrame;
 
 namespace webkit_media {
 
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
     WebMediaPlayerManagerAndroid* manager,
     WebMediaPlayerProxyAndroid* proxy,
     StreamTextureFactory* factory,
-    media::MediaLog* media_log)
+    media::MediaLog* media_log,
+    MediaStreamClient* media_stream_client,
+    media::Demuxer* demuxer)
     : frame_(frame),
       client_(client),
       buffered_(1u),
       main_loop_(base::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),
       needs_external_surface_(false),
       video_frame_provider_client_(NULL),
       proxy_(proxy),
       current_time_(0),
-      media_log_(media_log) {
+      media_log_(media_log),
+      media_stream_client_(media_stream_client),
+      demuxer_(demuxer) {
   main_loop_->AddDestructionObserver(this);
   if (manager_)
     player_id_ = manager_->RegisterMediaPlayer(this);
 
   if (stream_texture_factory_.get()) {
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
     stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
     ReallocateVideoFrame();
   }
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   SetVideoFrameProviderClient(NULL);
   client_->setWebLayer(NULL);
 
   if (proxy_)
     proxy_->DestroyPlayer(player_id_);
 
   if (stream_id_)
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
 
   if (manager_)
     manager_->UnregisterMediaPlayer(player_id_);
 
   if (main_loop_)
     main_loop_->RemoveDestructionObserver(this);
+#if defined(GOOGLE_TV)
+  if (audio_renderer_) {
+    if (audio_renderer_->IsLocalRenderer()) {
+      audio_renderer_->Stop();
+    } else if (!paused()) {
+      // The |audio_renderer_| can be shared by multiple remote streams, and
+      // it will be stopped when WebRtcAudioDeviceImpl goes away. So we simply
+      // pause the |audio_renderer_| here to avoid re-creating the
+      // |audio_renderer_|.
+      audio_renderer_->Pause();
+    }
+  }
+#endif
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url, CORSMode cors_mode) {
   load(url, NULL, cors_mode);
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url,
                                  WebMediaSource* media_source,
                                  CORSMode cors_mode) {
   if (cors_mode != CORSModeUnspecified)
     NOTIMPLEMENTED() << "No CORS support";
 
-  scoped_ptr<WebKit::WebMediaSource> scoped_media_source(media_source);
+  MediaPlayerBridge::MediaSource media_source_type =
+      MediaPlayerBridge::MEDIA_SOURCE_URL;
 #if defined(GOOGLE_TV)
   if (media_source) {
-    media_source_delegate_.reset(
-        new MediaSourceDelegate(
-            frame_, client_, proxy_, player_id_, media_log_));
+    media_source_type = MediaPlayerBridge::MEDIA_SOURCE_MSE;
+
     // |media_source_delegate_| is owned, so Unretained() is safe here.
-    media_source_delegate_->Initialize(
-        scoped_media_source.Pass(),
+    media_source_delegate_.reset(new MediaSourceDelegate(
+        proxy_, player_id_,
         base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
-                   base::Unretained(this)));
+                   base::Unretained(this))));
+    media_source_delegate_->InitializeMediaSource(
+        frame_, client_, media_source, media_log_);
+  } else if (media_stream_client_) {
+    media_source_type = MediaPlayerBridge::MEDIA_SOURCE_STREAM;
+
+    media_source_delegate_.reset(new MediaSourceDelegate(
+        proxy_, player_id_,
+        base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
+                   base::Unretained(this))));
+    media_source_delegate_->InitializeMediaStream(
+        demuxer_, destroy_demuxer_cb_);
+
+    audio_renderer_ = media_stream_client_->GetAudioRenderer(url);
+    if (audio_renderer_)
+      audio_renderer_->Start();
   }
+#else
+  if (media_source)
+    media_source_type = MediaPlayerBridge::MEDIA_SOURCE_MSE;
 #endif
 
+  InitializeMediaPlayer(url, media_source_type);
+}
+
+void WebMediaPlayerAndroid::InitializeMediaPlayer(
+    const WebURL& url,
+    MediaPlayerBridge::MediaSource media_source) {
   url_ = url;
   GURL first_party_url = frame_->document().firstPartyForCookies();
   if (proxy_) {
-    proxy_->Initialize(player_id_, url_, media_source != NULL, first_party_url);
+    proxy_->Initialize(player_id_, url, media_source, first_party_url);
     if (manager_->IsInFullscreen(frame_))
       proxy_->EnterFullscreen(player_id_);
   }
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
 }
 
 void WebMediaPlayerAndroid::cancelLoad() {
   NOTIMPLEMENTED();
 }
 
 void WebMediaPlayerAndroid::play() {
 #if defined(GOOGLE_TV)
   if (hasVideo() && needs_external_surface_) {
-    DCHECK(!needs_establish_peer_);
     if (proxy_)
       proxy_->RequestExternalSurface(player_id_, last_computed_rect_);
   }
+  if (audio_renderer_ && paused())
+    audio_renderer_->Play();
 #endif
   if (hasVideo() && needs_establish_peer_)
     EstablishSurfaceTexturePeer();
 
   if (paused() && proxy_)
     proxy_->Start(player_id_);
   is_playing_ = true;
 }
 
 void WebMediaPlayerAndroid::pause() {
+#if defined(GOOGLE_TV)
+  if (audio_renderer_ && !paused())
+    audio_renderer_->Pause();
+#endif
   if (proxy_)
     proxy_->Pause(player_id_);
   is_playing_ = false;
 }
 
 void WebMediaPlayerAndroid::seek(double seconds) {
   pending_seek_ = seconds;
   seeking_ = true;
 
   base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
@@ skipping 291 matching lines @@
 #if defined(GOOGLE_TV)
   static bool has_switch = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUseExternalVideoSurfaceThresholdInPixels);
   static int threshold = 0;
   static bool parsed_arg =
       has_switch &&
       base::StringToInt(
           CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               switches::kUseExternalVideoSurfaceThresholdInPixels),
           &threshold);
-
   if ((parsed_arg && threshold <= width * height) ||
       // Use H/W surface for MSE as the content is protected.
       media_source_delegate_) {
     needs_external_surface_ = true;
     SetNeedsEstablishPeer(false);
     if (!paused() && proxy_)
       proxy_->RequestExternalSurface(player_id_, last_computed_rect_);
   }
 #endif
 
@@ skipping 169 matching lines @@
 
   // Return false when the geometry hasn't been changed from the last time.
   if (last_computed_rect_ == *rect)
     return false;
 
   // Store the changed geometry information when it is actually changed.
   last_computed_rect_ = *rect;
   return true;
 }
 
-WebMediaPlayer::MediaKeyException
-WebMediaPlayerAndroid::generateKeyRequest(const WebString& key_system,
-                                              const unsigned char* init_data,
-                                              unsigned init_data_length) {
+WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::generateKeyRequest(
+    const WebString& key_system,
+    const unsigned char* init_data,
+    unsigned init_data_length) {
   if (media_source_delegate_) {
     return media_source_delegate_->GenerateKeyRequest(
         key_system, init_data, init_data_length);
   }
   return MediaKeyExceptionKeySystemNotSupported;
 }
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::addKey(
     const WebString& key_system,
     const unsigned char* key,
@@ skipping 16 matching lines @@
   return MediaKeyExceptionKeySystemNotSupported;
 }
 
 void WebMediaPlayerAndroid::OnReadFromDemuxer(
     media::DemuxerStream::Type type, bool seek_done) {
   if (media_source_delegate_)
     media_source_delegate_->OnReadFromDemuxer(type, seek_done);
   else
     NOTIMPLEMENTED();
 }
+
+void WebMediaPlayerAndroid::SetDestroyDemuxerCB(
+    const MediaSourceDelegate::DestroyDemuxerCB& destroy_demuxer_cb) {
+  destroy_demuxer_cb_ = destroy_demuxer_cb;
+}
 #endif
 
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (proxy_ && manager_->CanEnterFullscreen(frame_)) {
     proxy_->EnterFullscreen(player_id_);
     SetNeedsEstablishPeer(false);
   }
 }
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   if (proxy_)
     proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace webkit_media