[Chromecast] Upgrade to new CMA backend API

chromecast/media/cma/pipeline/media_pipeline_impl.cc

 // Copyright 2014 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 "chromecast/media/cma/pipeline/media_pipeline_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chromecast/media/cdm/browser_cdm_cast.h"
 #include "chromecast/media/cma/base/buffering_controller.h"
 #include "chromecast/media/cma/base/buffering_state.h"
 #include "chromecast/media/cma/base/cma_logging.h"
 #include "chromecast/media/cma/base/coded_frame_provider.h"
 #include "chromecast/media/cma/pipeline/audio_pipeline_impl.h"
 #include "chromecast/media/cma/pipeline/video_pipeline_impl.h"
-#include "chromecast/public/media/media_clock_device.h"
 #include "chromecast/public/media/media_pipeline_backend.h"
 #include "media/base/timestamp_constants.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
 // Buffering parameters when load_type is kLoadTypeUrl.
 const base::TimeDelta kLowBufferThresholdURL(
@@ skipping 11 matching lines @@
 const base::TimeDelta kTimeUpdateInterval(
     base::TimeDelta::FromMilliseconds(250));
 
 // Interval between two updates of the statistics is equal to:
 // kTimeUpdateInterval * kStatisticsUpdatePeriod.
 const int kStatisticsUpdatePeriod = 4;
 
 }  // namespace
 
 MediaPipelineImpl::MediaPipelineImpl()
-    : has_audio_(false),
+    : audio_decoder_(nullptr),
+      video_decoder_(nullptr),
+      backend_initialized_(false),
+      has_audio_(false),
       has_video_(false),
-      target_playback_rate_(0.0),
+      paused_(false),
+      target_playback_rate_(1.0f),
       enable_time_update_(false),
       pending_time_update_task_(false),
       statistics_rolling_counter_(0),
       weak_factory_(this) {
   CMALOG(kLogControl) << __FUNCTION__;
   weak_this_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 }
 
 MediaPipelineImpl::~MediaPipelineImpl() {
@@ skipping 10 matching lines @@
   if (!client_.pipeline_backend_destroyed_cb.is_null())
     client_.pipeline_backend_destroyed_cb.Run();
 }
 
 void MediaPipelineImpl::Initialize(
     LoadType load_type,
     scoped_ptr<MediaPipelineBackend> media_pipeline_backend) {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   media_pipeline_backend_.reset(media_pipeline_backend.release());
-  clock_device_ = media_pipeline_backend_->GetClock();
   if (!client_.pipeline_backend_created_cb.is_null())
     client_.pipeline_backend_created_cb.Run();
 
   if (load_type == kLoadTypeURL || load_type == kLoadTypeMediaSource) {
     base::TimeDelta low_threshold(kLowBufferThresholdURL);
     base::TimeDelta high_threshold(kHighBufferThresholdURL);
     if (load_type == kLoadTypeMediaSource) {
       low_threshold = kLowBufferThresholdMediaSource;
       high_threshold = kHighBufferThresholdMediaSource;
     }
     scoped_refptr<BufferingConfig> buffering_config(
         new BufferingConfig(low_threshold, high_threshold));
     buffering_controller_.reset(new BufferingController(
         buffering_config,
         base::Bind(&MediaPipelineImpl::OnBufferingNotification, weak_this_)));
   }
-
-  audio_pipeline_.reset(
-      new AudioPipelineImpl(media_pipeline_backend_->GetAudio()));
-
-  video_pipeline_.reset(
-      new VideoPipelineImpl(media_pipeline_backend_->GetVideo()));
 }
 
 void MediaPipelineImpl::SetClient(const MediaPipelineClient& client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!client.error_cb.is_null());
   DCHECK(!client.time_update_cb.is_null());
   DCHECK(!client.buffering_state_cb.is_null());
   DCHECK(!client.pipeline_backend_created_cb.is_null());
   DCHECK(!client.pipeline_backend_destroyed_cb.is_null());
   client_ = client;
 }
 
 void MediaPipelineImpl::SetCdm(int cdm_id) {
   CMALOG(kLogControl) << __FUNCTION__ << " cdm_id=" << cdm_id;
   DCHECK(thread_checker_.CalledOnValidThread());
   NOTIMPLEMENTED();
   // TODO(gunsch): SetCdm(int) is not implemented.
   // One possibility would be a GetCdmByIdCB that's passed in.
 }
 
+void MediaPipelineImpl::OnVideoResolutionChanged(
+    MediaPipelineBackend::VideoDecoder* decoder,
+    const Size& size) {
+  DCHECK(decoder == video_decoder_);
+  video_pipeline_->OnNaturalSizeChanged(size);
+}
+
+void MediaPipelineImpl::OnPushBufferComplete(
+    MediaPipelineBackend::Decoder* decoder,
+    MediaPipelineBackend::BufferStatus status) {
+  if (decoder == audio_decoder_)
+    audio_pipeline_->OnBufferPushed(status);
+  else if (decoder == video_decoder_)
+    video_pipeline_->OnBufferPushed(status);
+}
+
+void MediaPipelineImpl::OnEndOfStream(MediaPipelineBackend::Decoder* decoder) {
+  if (decoder == audio_decoder_)
+    audio_pipeline_->OnEndOfStream();
+  else if (decoder == video_decoder_)
+    video_pipeline_->OnEndOfStream();
+}
+
+void MediaPipelineImpl::OnDecoderError(MediaPipelineBackend::Decoder* decoder) {
+  if (decoder == audio_decoder_)
+    audio_pipeline_->OnError();
+  else if (decoder == video_decoder_)
+    video_pipeline_->OnError();
+}
+
 void MediaPipelineImpl::SetCdm(BrowserCdmCast* cdm) {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   audio_pipeline_->SetCdm(cdm);
   video_pipeline_->SetCdm(cdm);
 }
 
-AudioPipeline* MediaPipelineImpl::GetAudioPipeline() const {
-  return audio_pipeline_.get();
-}
-
-VideoPipeline* MediaPipelineImpl::GetVideoPipeline() const {
-  return video_pipeline_.get();
-}
-
 void MediaPipelineImpl::InitializeAudio(
     const ::media::AudioDecoderConfig& config,
+    const AvPipelineClient& client,
     scoped_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!has_audio_);
-  if (clock_device_->GetState() == MediaClockDevice::kStateUninitialized &&
-      !clock_device_->SetState(MediaClockDevice::kStateIdle)) {
-    status_cb.Run(::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
+
+  has_audio_ = true;
+
+  audio_decoder_ = media_pipeline_backend_->CreateAudioDecoder();
+  if (!audio_decoder_) {
+    status_cb.Run(::media::PIPELINE_ERROR_ABORT);
     return;
   }
-  has_audio_ = true;
+  audio_pipeline_.reset(new AudioPipelineImpl(audio_decoder_, client));
   audio_pipeline_->Initialize(config, frame_provider.Pass(), status_cb);
 }
 
 void MediaPipelineImpl::InitializeVideo(
-    const std::vector<::media::VideoDecoderConfig>& configs,
+    const std::vector< ::media::VideoDecoderConfig>& configs,
+    const VideoPipelineClient& client,
     scoped_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!has_video_);
-  if (clock_device_->GetState() == MediaClockDevice::kStateUninitialized &&
-      !clock_device_->SetState(MediaClockDevice::kStateIdle)) {
-    status_cb.Run(::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
+
+  has_video_ = true;
+  video_decoder_ = media_pipeline_backend_->CreateVideoDecoder();
+  if (!video_decoder_) {
+    status_cb.Run(::media::PIPELINE_ERROR_ABORT);
     return;
   }
-  has_video_ = true;
+  video_pipeline_.reset(new VideoPipelineImpl(video_decoder_, client));
+
   video_pipeline_->Initialize(configs, frame_provider.Pass(), status_cb);
 }
 
 void MediaPipelineImpl::StartPlayingFrom(base::TimeDelta time) {
   CMALOG(kLogControl) << __FUNCTION__ << " t0=" << time.InMilliseconds();
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(has_audio_ || has_video_);
   DCHECK(!pending_flush_callbacks_);
+  // When starting, we always enter the "playing" state (not paused).
+  paused_ = false;
 
-  // Reset the start of the timeline.
-  DCHECK_EQ(clock_device_->GetState(), MediaClockDevice::kStateIdle);
-  clock_device_->ResetTimeline(time.InMicroseconds());
+  // Lazy initialise
+  if (!backend_initialized_) {
+    backend_initialized_ = media_pipeline_backend_->Initialize(this);
+    if (!backend_initialized_) {
+      OnError(::media::PIPELINE_ERROR_ABORT);
+      return;
+    }
+  }
 
-  // Start the clock. If the playback rate is 0, then the clock is started
-  // but does not increase.
-  if (!clock_device_->SetState(MediaClockDevice::kStateRunning)) {
+  // Start the backend.
+  if (!media_pipeline_backend_->Start(time.InMicroseconds())) {
     OnError(::media::PIPELINE_ERROR_ABORT);
     return;
   }
 
   // Enable time updates.
   enable_time_update_ = true;
   statistics_rolling_counter_ = 0;
   if (!pending_time_update_task_) {
     pending_time_update_task_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 19 matching lines @@
       return;
     }
   }
 }
 
 void MediaPipelineImpl::Flush(const ::media::PipelineStatusCB& status_cb) {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(has_audio_ || has_video_);
   DCHECK(!pending_flush_callbacks_);
-  DCHECK(clock_device_->GetState() == MediaClockDevice::kStateUninitialized ||
-         clock_device_->GetState() == MediaClockDevice::kStateRunning);
 
   // No need to update media time anymore.
   enable_time_update_ = false;
 
   buffering_controller_->Reset();
 
-  // The clock should return to idle.
-  if (!clock_device_->SetState(MediaClockDevice::kStateIdle)) {
+  // Stop the backend
+  if (!media_pipeline_backend_->Stop()) {
     status_cb.Run(::media::PIPELINE_ERROR_ABORT);
     return;
   }
 
   // Flush both the audio and video pipeline.
   ::media::SerialRunner::Queue bound_fns;
   if (has_audio_) {
     bound_fns.Push(base::Bind(
         &AudioPipelineImpl::Flush,
         base::Unretained(audio_pipeline_.get())));
@@ skipping 15 matching lines @@
   DCHECK(has_audio_ || has_video_);
 
   // Cancel pending flush callbacks since we are about to stop/shutdown
   // audio/video pipelines. This will ensure A/V Flush won't happen in
   // stopped state.
   pending_flush_callbacks_.reset();
 
   // No need to update media time anymore.
   enable_time_update_ = false;
 
-  // Release hardware resources on Stop.
-  // Note: Stop can be called from any state.
-  if (clock_device_->GetState() == MediaClockDevice::kStateRunning)
-    clock_device_->SetState(MediaClockDevice::kStateIdle);
-  if (clock_device_->GetState() == MediaClockDevice::kStateIdle)
-    clock_device_->SetState(MediaClockDevice::kStateUninitialized);
-
   // Stop both the audio and video pipeline.
   if (has_audio_)
     audio_pipeline_->Stop();
   if (has_video_)
     video_pipeline_->Stop();
+
+  // Release hardware resources on Stop.
+  audio_pipeline_ = nullptr;
+  video_pipeline_ = nullptr;
+  media_pipeline_backend_.reset();
 }
 
 void MediaPipelineImpl::SetPlaybackRate(double rate) {
   CMALOG(kLogControl) << __FUNCTION__ << " rate=" << rate;
   DCHECK(thread_checker_.CalledOnValidThread());
+  if (!buffering_controller_ || !buffering_controller_->IsBuffering()) {
+    if (paused_ && rate != 0.0f) {
+      if (rate != target_playback_rate_)
+        media_pipeline_backend_->SetPlaybackRate(rate);
+      paused_ = false;
+      media_pipeline_backend_->Resume();
+    } else if (!paused_ && rate == 0.0f) {
+      paused_ = true;
+      media_pipeline_backend_->Pause();
+    } else {
+      media_pipeline_backend_->SetPlaybackRate(rate);
+    }
+  }
   target_playback_rate_ = rate;
-  if (!buffering_controller_ || !buffering_controller_->IsBuffering())
-    media_pipeline_backend_->GetClock()->SetRate(rate);
 }
 
-AudioPipelineImpl* MediaPipelineImpl::GetAudioPipelineImpl() const {
-  return audio_pipeline_.get();
-}
-
-VideoPipelineImpl* MediaPipelineImpl::GetVideoPipelineImpl() const {
-  return video_pipeline_.get();
+void MediaPipelineImpl::SetVolume(float volume) {
+  CMALOG(kLogControl) << __FUNCTION__ << " vol=" << volume;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(audio_pipeline_);
+  audio_pipeline_->SetVolume(volume);
 }
 
 void MediaPipelineImpl::StateTransition(
     const ::media::PipelineStatusCB& status_cb,
     ::media::PipelineStatus status) {
   pending_flush_callbacks_.reset();
   status_cb.Run(status);
 }
 
 void MediaPipelineImpl::OnBufferingNotification(bool is_buffering) {
   CMALOG(kLogControl) << __FUNCTION__ << " is_buffering=" << is_buffering;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(buffering_controller_);
 
   if (!client_.buffering_state_cb.is_null()) {
     ::media::BufferingState buffering_state = is_buffering ?
         ::media::BUFFERING_HAVE_NOTHING : ::media::BUFFERING_HAVE_ENOUGH;
     client_.buffering_state_cb.Run(buffering_state);
   }
 
-  if (media_pipeline_backend_->GetClock()->GetState() ==
-      MediaClockDevice::kStateUninitialized) {
-    return;
-  }
-
   if (is_buffering) {
     // Do not consume data in a rebuffering phase.
-    media_pipeline_backend_->GetClock()->SetRate(0.0);
-  } else {
-    media_pipeline_backend_->GetClock()->SetRate(target_playback_rate_);
+    if (!paused_) {
+      paused_ = true;
+      media_pipeline_backend_->Pause();
+    }
+  } else if (paused_) {
+    paused_ = false;
+    media_pipeline_backend_->Resume();
   }
 }
 
 void MediaPipelineImpl::UpdateMediaTime() {
   pending_time_update_task_ = false;
   if (!enable_time_update_)
     return;
 
   if (statistics_rolling_counter_ == 0) {
-    audio_pipeline_->UpdateStatistics();
-    video_pipeline_->UpdateStatistics();
+    if (audio_pipeline_)
+      audio_pipeline_->UpdateStatistics();
+    if (video_pipeline_)
+      video_pipeline_->UpdateStatistics();
   }
   statistics_rolling_counter_ =
       (statistics_rolling_counter_ + 1) % kStatisticsUpdatePeriod;
 
-  base::TimeDelta media_time =
-      base::TimeDelta::FromMicroseconds(clock_device_->GetTimeMicroseconds());
+  base::TimeDelta media_time = base::TimeDelta::FromMicroseconds(
+      media_pipeline_backend_->GetCurrentPts());
   if (media_time == ::media::kNoTimestamp()) {
     pending_time_update_task_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
         kTimeUpdateInterval);
     return;
   }
   base::TimeTicks stc = base::TimeTicks::Now();
 
   base::TimeDelta max_rendering_time = media_time;
@@ skipping 25 matching lines @@
 
 void MediaPipelineImpl::OnError(::media::PipelineStatus error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(error, ::media::PIPELINE_OK) << "PIPELINE_OK is not an error!";
   if (!client_.error_cb.is_null())
     client_.error_cb.Run(error);
 }
 
 }  // namespace media
 }  // namespace chromecast