Load CMA backend from shared library

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/backend/media_clock_device.h"
-#include "chromecast/media/cma/backend/media_pipeline_device.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/buffers.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
 // Buffering parameters when load_type is kLoadTypeUrl.
 const base::TimeDelta kLowBufferThresholdURL(
     base::TimeDelta::FromMilliseconds(2000));
@@ skipping 29 matching lines @@
   thread_checker_.DetachFromThread();
 }
 
 MediaPipelineImpl::~MediaPipelineImpl() {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void MediaPipelineImpl::Initialize(
     LoadType load_type,
-    scoped_ptr<MediaPipelineDevice> media_pipeline_device) {
+    scoped_ptr<MediaPipelineBackend> media_pipeline_backend) {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
-  media_pipeline_device_.reset(media_pipeline_device.release());
-  clock_device_ = media_pipeline_device_->GetMediaClockDevice();
+  media_pipeline_backend_.reset(media_pipeline_backend.release());
+  clock_device_ = media_pipeline_backend_->GetClock();
 
   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_device_->GetAudioPipelineDevice()));
+  audio_pipeline_.reset(
+      new AudioPipelineImpl(media_pipeline_backend_->GetAudio()));
 
-  video_pipeline_.reset(new VideoPipelineImpl(
-      media_pipeline_device_->GetVideoPipelineDevice()));
+  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());
   client_ = client;
 }
 
@@ skipping 51 matching lines @@
 }
 
 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_);
 
   // Reset the start of the timeline.
   DCHECK_EQ(clock_device_->GetState(), MediaClockDevice::kStateIdle);
-  clock_device_->ResetTimeline(time);
+  clock_device_->ResetTimeline(time.InMicroseconds());
 
   // Start the clock. If the playback rate is 0, then the clock is started
   // but does not increase.
   if (!clock_device_->SetState(MediaClockDevice::kStateRunning)) {
     OnError(::media::PIPELINE_ERROR_ABORT);
     return;
   }
 
   // Enable time updates.
   enable_time_update_ = true;
@@ skipping 23 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)) {
     status_cb.Run(::media::PIPELINE_ERROR_ABORT);
     return;
@@ skipping 42 matching lines @@
     audio_pipeline_->Stop();
   if (has_video_)
     video_pipeline_->Stop();
 }
 
 void MediaPipelineImpl::SetPlaybackRate(double rate) {
   CMALOG(kLogControl) << __FUNCTION__ << " rate=" << rate;
   DCHECK(thread_checker_.CalledOnValidThread());
   target_playback_rate_ = rate;
   if (!buffering_controller_ || !buffering_controller_->IsBuffering())
-    media_pipeline_device_->GetMediaClockDevice()->SetRate(rate);
+    media_pipeline_backend_->GetClock()->SetRate(rate);
 }
 
 AudioPipelineImpl* MediaPipelineImpl::GetAudioPipelineImpl() const {
   return audio_pipeline_.get();
 }
 
 VideoPipelineImpl* MediaPipelineImpl::GetVideoPipelineImpl() const {
   return video_pipeline_.get();
 }
 
 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_device_->GetMediaClockDevice()->GetState() ==
+  if (media_pipeline_backend_->GetClock()->GetState() ==
       MediaClockDevice::kStateUninitialized) {
     return;
   }
 
   if (is_buffering) {
     // Do not consume data in a rebuffering phase.
-    media_pipeline_device_->GetMediaClockDevice()->SetRate(0.0);
+    media_pipeline_backend_->GetClock()->SetRate(0.0);
   } else {
-    media_pipeline_device_->GetMediaClockDevice()->SetRate(
-        target_playback_rate_);
+    media_pipeline_backend_->GetClock()->SetRate(target_playback_rate_);
   }
 }
 
 void MediaPipelineImpl::UpdateMediaTime() {
   pending_time_update_task_ = false;
   if (!enable_time_update_)
     return;
 
   if (statistics_rolling_counter_ == 0) {
     audio_pipeline_->UpdateStatistics();
     video_pipeline_->UpdateStatistics();
   }
   statistics_rolling_counter_ =
       (statistics_rolling_counter_ + 1) % kStatisticsUpdatePeriod;
 
-  base::TimeDelta media_time(clock_device_->GetTime());
+  base::TimeDelta media_time =
+      base::TimeDelta::FromMicroseconds(clock_device_->GetTimeMicroseconds());
   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