Implementation of MediaCodecPlayer stage 1

media/base/android/media_codec_player.cc

 // Copyright 2015 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 "media/base/android/media_codec_player.h"
 
+#include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/threading/thread.h"
+
+#include "media/base/android/media_codec_audio_decoder.h"
+#include "media/base/android/media_codec_player_state.h"
+#include "media/base/android/media_codec_video_decoder.h"
+#include "media/base/android/media_player_manager.h"
+#include "media/base/buffers.h"
 
 #define RUN_ON_MEDIA_THREAD(METHOD, ...)                                      \
   do {                                                                        \
     if (!GetMediaTaskRunner()->BelongsToCurrentThread()) {                    \
       GetMediaTaskRunner()->PostTask(                                         \
           FROM_HERE,                                                          \
           base::Bind(&MediaCodecPlayer:: METHOD, weak_this_, ##__VA_ARGS__)); \
       return;                                                                 \
     }                                                                         \
   } while(0)
@@ skipping 10 matching lines @@
 
 // Create media thread
 base::LazyInstance<MediaThread>::Leaky
     g_media_thread = LAZY_INSTANCE_INITIALIZER;
 
 
 scoped_refptr<base::SingleThreadTaskRunner> GetMediaTaskRunner() {
   return g_media_thread.Pointer()->task_runner();
 }
 
+
 // MediaCodecPlayer implementation.
 
 MediaCodecPlayer::MediaCodecPlayer(
     int player_id,
-    MediaPlayerManager* manager,
+    base::WeakPtr<MediaPlayerManager> manager,
     const RequestMediaResourcesCB& request_media_resources_cb,
     scoped_ptr<DemuxerAndroid> demuxer,
     const GURL& frame_url)
     : MediaPlayerAndroid(player_id,
-                         manager,
+                         manager.get(),
                          request_media_resources_cb,
                          frame_url),
       ui_task_runner_(base::MessageLoopProxy::current()),
       demuxer_(demuxer.Pass()),
+      state_(StatePaused::Instance()),
+      interpolator_(&default_tick_clock_),
+      pending_start_(false),
       weak_factory_(this) {
   // UI thread
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "MediaCodecPlayer::MediaCodecPlayer: player_id:" << player_id;
 
+  request_resources_cb_ = base::Bind(request_media_resources_cb_, player_id);
+
+  metadata_changed_cb_ = base::Bind(
+      &MediaPlayerManager::OnMediaMetadataChanged, manager, player_id);
+  time_update_cb_ = base::Bind(
+      &MediaPlayerManager::OnTimeUpdate, manager, player_id);
+  completion_cb_ = base::Bind(
+      &MediaPlayerManager::OnPlaybackComplete, manager, player_id);
+  attach_listener_cb_ = base::Bind(
+      &MediaPlayerAndroid::AttachListener, WeakPtrForUIThread(), nullptr);
+  detach_listener_cb_ = base::Bind(
+      &MediaPlayerAndroid::DetachListener, WeakPtrForUIThread());
+
   weak_this_ = weak_factory_.GetWeakPtr();
 
   // Finish initializaton on Media thread
   GetMediaTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&MediaCodecPlayer::Initialize, weak_this_));
 }
 
 MediaCodecPlayer::~MediaCodecPlayer()
 {
   // Media thread
   DVLOG(1) << "MediaCodecPlayer::~MediaCodecPlayer";
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+
+  // Stop decoder threads before destroying decoders
+  ReleaseDecoderResources();
 }
 
 void MediaCodecPlayer::Initialize() {
   // Media thread
   DVLOG(1) << __FUNCTION__;
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   demuxer_->Initialize(this);
+
+  interpolator_.SetUpperBound(base::TimeDelta());
+
+  CreateDecoders();
 }
 
-// MediaPlayerAndroid implementation.
+// The implementation of MediaPlayerAndroid interface.
 
 void MediaCodecPlayer::DeleteOnCorrectThread() {
   // UI thread
   DVLOG(1) << __FUNCTION__;
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
-  // The listener-related portion of the base class has to be
-  // destroyed on UI thread.
+  DetachListener();
+
+  // The base class part that deals with MediaPlayerListener
+  // has to be destroyed on UI thread.
   DestroyListenerOnUIThread();
 
   // Post deletion onto Media thread
   GetMediaTaskRunner()->DeleteSoon(FROM_HERE, this);
 }
 
 void MediaCodecPlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   RUN_ON_MEDIA_THREAD(SetVideoSurface, base::Passed(&surface));
 
   // Media thread
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__ << (surface.IsEmpty() ? " empty" : " non-empty");
 
-  NOTIMPLEMENTED();
+  // I assume that if video decoder already has the surface,
+  // there will be two calls:
+  // (1) SetVideoSurface(0)
+  // (2) SetVideoSurface(new_surface)
+  video_decoder_->SetPendingSurface(surface.Pass());
+
+  if (!video_decoder_->HasPendingSurface())
+    state_->EventVideoSurfaceRemoved(this);
+  else
+    state_->EventSetVideoSurface(this);
 }
 
 void MediaCodecPlayer::Start() {
   RUN_ON_MEDIA_THREAD(Start);
 
   // Media thread
   DVLOG(1) << __FUNCTION__;
-
-  NOTIMPLEMENTED();
+  state_->EventStart(this);
 }
 
 void MediaCodecPlayer::Pause(bool is_media_related_action) {
   RUN_ON_MEDIA_THREAD(Pause, is_media_related_action);
 
   // Media thread
   DVLOG(1) << __FUNCTION__;
-
-  NOTIMPLEMENTED();
+  state_->EventPause(this);
 }
 
 void MediaCodecPlayer::SeekTo(base::TimeDelta timestamp) {
   RUN_ON_MEDIA_THREAD(SeekTo, timestamp);
 
   // Media thread
   DVLOG(1) << __FUNCTION__ << " " << timestamp;
-
-  NOTIMPLEMENTED();
+  state_->EventSeekTo(this, timestamp);
 }
 
 void MediaCodecPlayer::Release() {
   RUN_ON_MEDIA_THREAD(Release);
 
   // Media thread
   DVLOG(1) << __FUNCTION__;
-
-  NOTIMPLEMENTED();
+  state_->EventRelease(this);
 }
 
 void MediaCodecPlayer::SetVolume(double volume) {
   RUN_ON_MEDIA_THREAD(SetVolume, volume);
 
   // Media thread
   DVLOG(1) << __FUNCTION__ << " " << volume;
-
-  NOTIMPLEMENTED();
+  audio_decoder_->SetVolume(volume);
 }
 
 int MediaCodecPlayer::GetVideoWidth() {
-  // UI thread
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  NOTIMPLEMENTED();
-  return 320;
+  // UI thread, Media thread
+  return video_decoder_->GetVideoWidth();
 }
 
 int MediaCodecPlayer::GetVideoHeight() {
-  // UI thread
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  NOTIMPLEMENTED();
-  return 240;
+  // UI thread, Media thread
+  return video_decoder_->GetVideoHeight();
 }
 
 base::TimeDelta MediaCodecPlayer::GetCurrentTime() {
   // UI thread, Media thread
-  NOTIMPLEMENTED();
-  return base::TimeDelta();
+  base::TimeDelta interpolator_result;
+  {
+    base::AutoLock lock(interpolator_lock_);
+    interpolator_result = interpolator_.GetInterpolatedTime();
+  }
+  return std::min(interpolator_result, duration_);
 }
 
 base::TimeDelta MediaCodecPlayer::GetDuration() {
   // UI thread
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  NOTIMPLEMENTED();
-  return base::TimeDelta();
+  return duration_;
 }
 
 bool MediaCodecPlayer::IsPlaying() {
   // UI thread
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  NOTIMPLEMENTED();
-  return false;
+  return state_ == StatePlaying::Instance();
 }
 
 bool MediaCodecPlayer::CanPause() {
   // UI thread
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   NOTIMPLEMENTED();
   return false;
 }
 
 bool MediaCodecPlayer::CanSeekForward() {
   // UI thread
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   NOTIMPLEMENTED();
   return false;
 }
 
 bool MediaCodecPlayer::CanSeekBackward() {
   // UI thread
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   NOTIMPLEMENTED();
   return false;
 }
 
 bool MediaCodecPlayer::IsPlayerReady() {
   // UI thread
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  NOTIMPLEMENTED();
+  // This method is called to check whether it' save to release
+  // this player if the OS needs more resources.
+  // For this player Release() can be called at any time.
   return true;
 }
 
 void MediaCodecPlayer::SetCdm(BrowserCdm* cdm) {
   // UI thread
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   NOTIMPLEMENTED();
 }
 
 // Callbacks from Demuxer.
 
 void MediaCodecPlayer::OnDemuxerConfigsAvailable(
     const DemuxerConfigs& configs) {
   // Media thread
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
-  NOTIMPLEMENTED();
+  duration_ = configs.duration;
+
+  state_->EventDemuxerConfigsAvailable(this, configs);
+
+  // Post on UI thread
+  ui_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(metadata_changed_cb_, duration_,
+                 GetVideoWidth(), GetVideoHeight(), true));
 }
 
 void MediaCodecPlayer::OnDemuxerDataAvailable(const DemuxerData& data) {
   // Media thread
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  NOTIMPLEMENTED();
+
+  DCHECK_LT(0u, data.access_units.size());
+  CHECK_GE(1u, data.demuxer_configs.size());
+
+  DVLOG(2) << "Player::" << __FUNCTION__;
+
+  if (data.type == DemuxerStream::AUDIO)
+    audio_decoder_->OnDemuxerDataAvailable(data);
+
+  if (data.type == DemuxerStream::VIDEO)
+    video_decoder_->OnDemuxerDataAvailable(data);
 }
 
 void MediaCodecPlayer::OnDemuxerSeekDone(
     base::TimeDelta actual_browser_seek_time) {
   // Media thread
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+
+  DVLOG(1) << __FUNCTION__ << " actual_time:" << actual_browser_seek_time;
+
   NOTIMPLEMENTED();
 }
 
 void MediaCodecPlayer::OnDemuxerDurationChanged(
     base::TimeDelta duration) {
   // Media thread
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  NOTIMPLEMENTED();
+  DVLOG(1) << __FUNCTION__ << " duration:" << duration;
+  duration_ = duration;
+}
+
+
+// Events from Decoders, called on Media thread
+
+void MediaCodecPlayer::RequestDemuxerData(DemuxerStream::Type stream_type) {
+  DVLOG(1) << __FUNCTION__ << " streamType:" << stream_type;
+
+  // Use this method instead of directly binding with
+  // DemuxerAndroid::RequestDemuxerData() to avoid the  race condition
+  // on deletion:
+  // 1. DestroySelf is posted from UI to Media thread.
+  // 2. RequestDemuxerData callback is posted from Decoder to Media thread.
+  // 3. DestroySelf arrives, we delete the player and detach from
+  //    BrowserDemuxerAndroid.
+  // 4. RequestDemuxerData is sent to the player, but weak_ptr blocks it.
+  //    If we used DemuxerAndroid::RequestDemuxerData() it would arrive,
+  //    but the client (i.e. this player) would not exist.
+  demuxer_->RequestDemuxerData(stream_type);
+}
+
+void MediaCodecPlayer::OnPrefetchDone() {
+  // Media thread
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+  state_->EventPrefetchDone(this);
+}
+
+void MediaCodecPlayer::OnStarvation() {
+  // Media thread
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+  state_->EventStarvation(this);
+}
+
+void MediaCodecPlayer::OnStopDone() {
+  // Media thread
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  if (audio_decoder_->IsStopped() && video_decoder_->IsStopped()) {
+    // At this point decoder threads should not be running
+    if (interpolator_.interpolating())
+      interpolator_.StopInterpolating();
+
+    state_->EventStopDone(this);
+
+    // DetachListener to UI thread
+    ui_task_runner_->PostTask(FROM_HERE, detach_listener_cb_);
+
+    if (AudioFinished() && VideoFinished())
+      ui_task_runner_->PostTask(FROM_HERE, completion_cb_);
+  }
+}
+
+void MediaCodecPlayer::OnError() {
+  // Media thread
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+  state_->EventError(this);
+}
+
+// Event from Decoders, called on Decoder thread
+
+void MediaCodecPlayer::OnTimeIntervalUpdate(base::TimeDelta now_playing,
+                                            base::TimeDelta last_buffered) {
+  // Decoder thread
+  base::TimeDelta current_time;
+  {
+    base::AutoLock lock(interpolator_lock_);
+    interpolator_.SetBounds(now_playing, last_buffered);
+
+    current_time = std::min(interpolator_.GetInterpolatedTime(), duration_);
+  }
+
+  // Post on UI thread
+  ui_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(time_update_cb_, current_time, base::TimeTicks::Now()));
+}
+
+// State machine operations, called on Media thread
+
+void MediaCodecPlayer::SetState(MediaCodecPlayerState* new_state) {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DCHECK(new_state);
+  DVLOG(1) << "SetState:" << state_->name() << " -> " << new_state->name();
+
+  state_ = new_state;
+}
+
+void MediaCodecPlayer::SetPendingSurface(gfx::ScopedJavaSurface surface) {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  video_decoder_->SetPendingSurface(surface.Pass());
+}
+
+bool MediaCodecPlayer::HasPendingSurface() {
+  return video_decoder_->HasPendingSurface();
+}
+
+void MediaCodecPlayer::SetPendingStart(bool need_to_start) {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__ << ": " << need_to_start;
+  pending_start_ = need_to_start;
+}
+
+bool MediaCodecPlayer::HasPendingStart() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  // Return and reset.
+  bool ret = pending_start_;
+  pending_start_ = false;
+  return ret;
+}
+
+bool MediaCodecPlayer::HasAudio() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  return audio_decoder_->HasStream();
+}
+
+bool MediaCodecPlayer::HasVideo() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  return video_decoder_->HasStream();
+}
+
+void MediaCodecPlayer::CreateDecoders() {
+  // Media thread
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  error_cb_ =  base::Bind(&MediaCodecPlayer::OnError, weak_this_);
+
+  audio_decoder_.reset(new MediaCodecAudioDecoder(
+      GetMediaTaskRunner(),
+      ui_task_runner_,
+      base::Bind(&MediaCodecPlayer::RequestDemuxerData, weak_this_,
+                 DemuxerStream::AUDIO),
+      base::Bind(&MediaCodecPlayer::OnStarvation, weak_this_),
+      base::Bind(&MediaCodecPlayer::OnStopDone, weak_this_),
+      error_cb_,
+      base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate,
+                 base::Unretained(this))));
+
+  video_decoder_.reset(new MediaCodecVideoDecoder(
+      GetMediaTaskRunner(),
+      ui_task_runner_,
+      base::Bind(&MediaCodecPlayer::RequestDemuxerData, weak_this_,
+                 DemuxerStream::VIDEO),
+      base::Bind(&MediaCodecPlayer::OnStarvation, weak_this_),
+      base::Bind(&MediaCodecPlayer::OnStopDone, weak_this_),
+      error_cb_,
+      request_resources_cb_));
+}
+
+bool MediaCodecPlayer::AudioFinished() {
+  return audio_decoder_->IsCompleted() || !audio_decoder_->HasStream();
+}
+
+bool MediaCodecPlayer::VideoFinished() {
+  return video_decoder_->IsCompleted() || !video_decoder_->HasStream();
+}
+
+void MediaCodecPlayer::SetDemuxerConfigs(const DemuxerConfigs& configs) {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  if (configs.audio_codec != kUnknownAudioCodec)
+    audio_decoder_->SetDemuxerConfigs(configs);
+
+  if (configs.video_codec != kUnknownVideoCodec)
+    video_decoder_->SetDemuxerConfigs(configs);
+}
+
+void MediaCodecPlayer::StartPrefetchDecoders() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  bool do_audio = false;
+  bool do_video = false;
+  int count = 0;
+  if (!AudioFinished()) {
+    do_audio = true;
+    ++count;
+  }
+  if (!VideoFinished()) {
+    do_video = true;
+    ++count;
+  }
+
+  DCHECK_LT(0, count); // at least one decoder should be active
+
+  base::Closure prefetch_cb = base::BarrierClosure(
+      count, base::Bind(&MediaCodecPlayer::OnPrefetchDone, weak_this_));
+
+  if (do_audio)
+    audio_decoder_->Prefetch(prefetch_cb);
+
+  if (do_video)
+    video_decoder_->Prefetch(prefetch_cb);
+}
+
+void MediaCodecPlayer::StartPlaybackDecoders() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  // Configure all streams before the start since
+  // we may discover that browser seek is required.
+
+  bool do_audio = !AudioFinished();
+  bool do_video = !VideoFinished();
+
+  // If there is nothing to play, the state machine should determine
+  // this at the prefetch state and never call this method.
+  DCHECK(do_audio || do_video);
+
+  if (do_audio) {
+    MediaCodecDecoder::ConfigStatus status = audio_decoder_->Configure();
+    if (status != MediaCodecDecoder::CONFIG_OK) {
+      GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
+      return;
+    }
+  }
+
+  if (do_video) {
+    MediaCodecDecoder::ConfigStatus status = video_decoder_->Configure();
+    if (status != MediaCodecDecoder::CONFIG_OK) {
+      GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
+      return;
+    }
+  }
+
+  // At this point decoder threads should not be running
+  if (!interpolator_.interpolating())
+    interpolator_.StartInterpolating();
+
+  if (do_audio) {
+    if (!audio_decoder_->Start(GetCurrentTime())) {
+      GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
+      return;
+    }
+
+    // Attach listener on UI thread
+    ui_task_runner_->PostTask(FROM_HERE, attach_listener_cb_);
+  }
+
+  if (do_video) {
+    if (!video_decoder_->Start(GetCurrentTime())) {
+      GetMediaTaskRunner()->PostTask(FROM_HERE, error_cb_);
+      return;
+    }
+  }
+}
+
+void MediaCodecPlayer::StopDecoders() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  audio_decoder_->SyncStop();
+  video_decoder_->SyncStop();
+}
+
+void MediaCodecPlayer::RequestToStopDecoders() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  bool do_audio = false;
+  bool do_video = false;
+  int count = 0;
+  if (audio_decoder_->IsPrefetchingOrPlaying()) {
+    do_audio = true;
+    ++count;
+  }
+  if (video_decoder_->IsPrefetchingOrPlaying()) {
+    do_video = true;
+    ++count;
+  }
+
+  if (count == 0) {
+    GetMediaTaskRunner()->PostTask(
+        FROM_HERE, base::Bind(&MediaCodecPlayer::OnStopDone, weak_this_));
+    return;
+  }
+
+  if (do_audio)
+    audio_decoder_->RequestToStop();
+
+  if (do_video)
+    video_decoder_->RequestToStop();
+}
+
+void MediaCodecPlayer::ReleaseDecoderResources() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  audio_decoder_->ReleaseDecoderResources();
+  video_decoder_->ReleaseDecoderResources();
+
+  // At this point decoder threads should not be running
+  if (interpolator_.interpolating())
+    interpolator_.StopInterpolating();
 }
 
 }  // namespace media