Load CMA backend from shared library

chromecast/media/cma/pipeline/av_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/av_pipeline_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
+#include "chromecast/base/time_conversions.h"
 #include "chromecast/media/base/decrypt_context.h"
 #include "chromecast/media/cdm/browser_cdm_cast.h"
-#include "chromecast/media/cma/backend/media_clock_device.h"
-#include "chromecast/media/cma/backend/media_component_device.h"
+#include "chromecast/media/cma/base/backend_client_callbacks.h"
 #include "chromecast/media/cma/base/buffering_frame_provider.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/base/decoder_buffer_base.h"
+#include "chromecast/media/cma/base/decoder_buffer_impl.h"
 #include "chromecast/media/cma/pipeline/decrypt_util.h"
+#include "chromecast/public/media/decrypt_config.h"
+#include "chromecast/public/media/media_clock_device.h"
+#include "chromecast/public/media/media_component_device.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/buffers.h"
 #include "media/base/decrypt_config.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
 const int kNoCallbackId = -1;
 
 }  // namespace
 
-AvPipelineImpl::AvPipelineImpl(
-    MediaComponentDevice* media_component_device,
-    const UpdateConfigCB& update_config_cb)
+AvPipelineImpl::AvPipelineImpl(MediaComponentDevice* media_component_device,
+                               const UpdateConfigCB& update_config_cb)
     : update_config_cb_(update_config_cb),
       media_component_device_(media_component_device),
       state_(kUninitialized),
-      buffered_time_(::media::kNoTimestamp()),
-      playable_buffered_time_(::media::kNoTimestamp()),
+      buffered_time_(TimeDelta::Invalid()),
+      playable_buffered_time_(TimeDelta::Invalid()),
       enable_feeding_(false),
       pending_read_(false),
       pending_push_(false),
       enable_time_update_(false),
       pending_time_update_task_(false),
       media_keys_(NULL),
       media_keys_callback_id_(kNoCallbackId),
       weak_factory_(this) {
   DCHECK(media_component_device);
   weak_this_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 }
 
 AvPipelineImpl::~AvPipelineImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  media_component_device_->SetClient(MediaComponentDevice::Client());
+  media_component_device_->SetClient(nullptr);
 
   if (media_keys_ && media_keys_callback_id_ != kNoCallbackId)
     media_keys_->UnregisterPlayer(media_keys_callback_id_);
 }
 
 void AvPipelineImpl::TransitionToState(State state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   state_ = state;
 }
 
@@ skipping 16 matching lines @@
 void AvPipelineImpl::SetClient(const AvPipelineClient& client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kUninitialized);
   client_ = client;
 }
 
 bool AvPipelineImpl::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kUninitialized);
 
-  MediaComponentDevice::Client client;
-  client.eos_cb = base::Bind(&AvPipelineImpl::OnEos, weak_this_);
-  media_component_device_->SetClient(client);
+  media_component_device_->SetClient(new MediaComponentDeviceClientImpl(
+      base::Bind(&AvPipelineImpl::OnEos, weak_this_)));
   if (!media_component_device_->SetState(MediaComponentDevice::kStateIdle))
     return false;
 
   return true;
 }
 
 bool AvPipelineImpl::StartPlayingFrom(
     base::TimeDelta time,
     const scoped_refptr<BufferingState>& buffering_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kFlushed);
 
   // Media time where rendering should start
   // and switch to a state where the audio device accepts incoming buffers.
-  if (!media_component_device_->SetStartPts(time) ||
+  TimeDelta start_time = FromBaseTimeDelta(time);
+  if (!media_component_device_->SetStartPts(start_time) ||
       !media_component_device_->SetState(MediaComponentDevice::kStatePaused)) {
     return false;
   }
 
   // Buffering related initialization.
   DCHECK(frame_provider_);
   buffering_state_ = buffering_state;
   if (buffering_state_.get())
     buffering_state_->SetMediaTime(time);
 
@@ skipping 18 matching lines @@
   pending_push_ = false;
 
   // Break the feeding loop.
   enable_feeding_ = false;
 
   // Remove any pending buffer.
   pending_buffer_ = scoped_refptr<DecoderBufferBase>();
 
   // Finally, remove any frames left in the frame provider.
   pending_read_ = false;
-  buffered_time_ = ::media::kNoTimestamp();
-  playable_buffered_time_ = ::media::kNoTimestamp();
+  buffered_time_ = TimeDelta::Invalid();

[gunsch, 2015/07/27 17:14:49]

To me, this re-affirms not having our own TimeDelta class. I think we'll be
better off continuing to use the ::media primitives here and uint64_t's
otherwise.

[servolk, 2015/07/27 21:25:47]

If our goal is to fully decouple CMA backend code from Chromium dependencies,
then we don't have much of a choice. Although personally, I agree, I think
having to duplicate this functionality is very unfortunate. Perhaps we could
keep dependency at least on Chromium base/? Wasn't there some effort to make
libbase more separate and easily shareable/packageable for use by third-party
devs?

[halliwell, 2015/07/28 02:19:35]

I've removed TimeDelta.  It made initial refactoring easier/more mechanical but
you're right it doesn't add much value.  And in fact most backend code seems to
work with raw integers anyway, so the code actually gets simpler after passing
integers through.

+  playable_buffered_time_ = TimeDelta::Invalid();
   non_playable_frames_.clear();
   frame_provider_->Flush(done_cb);
 }
 
 void AvPipelineImpl::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Stop can be called from any state.
   if (state_ == kUninitialized || state_ == kStopped)
     return;
@@ skipping 111 matching lines @@
     // If we do have the clear key, decrypt the pending buffer
     // and reset the decryption context (not needed anymore).
     crypto::SymmetricKey* key = decrypt_context->GetKey();
     if (key != NULL) {
       pending_buffer_ = DecryptDecoderBuffer(pending_buffer_, key);
       decrypt_context = scoped_refptr<DecryptContext>();
     }
   }
 
   if (!pending_buffer_->end_of_stream() && buffering_state_.get()) {
-    base::TimeDelta timestamp = pending_buffer_->timestamp();
+    base::TimeDelta timestamp = ToBaseTimeDelta(pending_buffer_->timestamp());
     if (timestamp != ::media::kNoTimestamp())
       buffering_state_->SetMaxRenderingTime(timestamp);
   }
 
+  CastKeySystem key_system =
+      decrypt_context ? decrypt_context->key_system() : KEY_SYSTEM_NONE;
   MediaComponentDevice::FrameStatus status = media_component_device_->PushFrame(
-      decrypt_context,
-      pending_buffer_,
-      base::Bind(&AvPipelineImpl::OnFramePushed, weak_this_));
+      key_system, new DecoderBufferImpl(pending_buffer_),
+      new FrameStatusCBImpl(
+          base::Bind(&AvPipelineImpl::OnFramePushed, weak_this_)));
   pending_buffer_ = scoped_refptr<DecoderBufferBase>();
 
   pending_push_ = (status == MediaComponentDevice::kFramePending);
   if (!pending_push_)
     OnFramePushed(status);
 }
 
 void AvPipelineImpl::OnFramePushed(MediaComponentDevice::FrameStatus status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   pending_push_ = false;
@@ skipping 24 matching lines @@
 }
 
 void AvPipelineImpl::OnFrameBuffered(
     const scoped_refptr<DecoderBufferBase>& buffer,
     bool is_at_max_capacity) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!buffering_state_.get())
     return;
 
-  if (!buffer->end_of_stream() &&
-      (buffered_time_ == ::media::kNoTimestamp() ||
-       buffered_time_ < buffer->timestamp())) {
+  if (!buffer->end_of_stream() && (buffered_time_ == TimeDelta::Invalid() ||
+                                   buffered_time_ < buffer->timestamp())) {
     buffered_time_ = buffer->timestamp();
   }
 
   if (is_at_max_capacity)
-    buffering_state_->NotifyMaxCapacity(buffered_time_);
+    buffering_state_->NotifyMaxCapacity(ToBaseTimeDelta(buffered_time_));
 
   // No need to update the list of playable frames,
   // if we are already blocking on a frame.
   bool update_playable_frames = non_playable_frames_.empty();
   non_playable_frames_.push_back(buffer);
   if (update_playable_frames)
     UpdatePlayableFrames();
 }
 
 void AvPipelineImpl::UpdatePlayableFrames() {
   while (!non_playable_frames_.empty()) {
     const scoped_refptr<DecoderBufferBase>& non_playable_frame =
         non_playable_frames_.front();
 
     if (non_playable_frame->end_of_stream()) {
       buffering_state_->NotifyEos();
     } else {
-      const ::media::DecryptConfig* decrypt_config =
+      const DecryptConfig* decrypt_config =
           non_playable_frame->decrypt_config();
       if (decrypt_config &&
           !(media_keys_ &&
             media_keys_->GetDecryptContext(decrypt_config->key_id()).get())) {
         // The frame is still not playable. All the following are thus not
         // playable.
         break;
       }
 
-      if (playable_buffered_time_ == ::media::kNoTimestamp() ||
+      if (playable_buffered_time_ == TimeDelta::Invalid() ||
           playable_buffered_time_ < non_playable_frame->timestamp()) {
         playable_buffered_time_ = non_playable_frame->timestamp();
-        buffering_state_->SetBufferedTime(playable_buffered_time_);
+        buffering_state_->SetBufferedTime(
+            ToBaseTimeDelta(playable_buffered_time_));
       }
     }
 
     // The frame is playable: remove it from the list of non playable frames.
     non_playable_frames_.pop_front();
   }
 }
 
 }  // namespace media
 }  // namespace chromecast