[Chromecast] Upgrade to new CMA backend API

chromecast/media/cma/backend/media_pipeline_backend_default.cc

Index: chromecast/media/cma/backend/media_pipeline_backend_default.cc
diff --git a/chromecast/media/cma/backend/media_pipeline_backend_default.cc b/chromecast/media/cma/backend/media_pipeline_backend_default.cc
index 498c5be257b58ad781fdf6a94cc97ae6d8e0cc80..6c92ad1fb81f92bd183f2de82c4a40d0c4f5a6c8 100644
--- a/chromecast/media/cma/backend/media_pipeline_backend_default.cc
+++ b/chromecast/media/cma/backend/media_pipeline_backend_default.cc
@@ -4,35 +4,150 @@
 
 #include "chromecast/media/cma/backend/media_pipeline_backend_default.h"
 
-#include "chromecast/media/cma/backend/audio_pipeline_device_default.h"
-#include "chromecast/media/cma/backend/media_clock_device_default.h"
-#include "chromecast/media/cma/backend/video_pipeline_device_default.h"
+#include "chromecast/public/media/cast_decoder_buffer.h"
 
 namespace chromecast {
 namespace media {
 
-MediaPipelineBackendDefault::MediaPipelineBackendDefault(
-    const MediaPipelineDeviceParams& params)
-    : params_(params) {}
+class MediaPipelineBackendDefault::AudioDecoderDefault
+    : public MediaPipelineBackend::AudioDecoder {
+ public:
+  AudioDecoderDefault() : delegate_(nullptr) {}
+  ~AudioDecoderDefault() override {}
 
-MediaPipelineBackendDefault::~MediaPipelineBackendDefault() {}
+  void SetDelegate(MediaPipelineBackend::Delegate* delegate) {
+    delegate_ = delegate;
+  }
 
-MediaClockDevice* MediaPipelineBackendDefault::GetClock() {
-  if (!clock_)
-    clock_.reset(new MediaClockDeviceDefault());
-  return clock_.get();
+  // MediaPipelineBackend::AudioDecoder implementation:
+  BufferStatus PushBuffer(DecryptContext* decrypt_context,
+                          CastDecoderBuffer* buffer) override {
+    if (buffer->end_of_stream())
+      delegate_->OnEndOfStream(this);
+    return MediaPipelineBackend::kBufferSuccess;
+  }
+
+  void GetStatistics(Statistics* statistics) override {}
+
+  bool SetConfig(const AudioConfig& config) override { return true; }
+
+  bool SetVolume(float multiplier) override { return true; }
+
+  RenderingDelay GetRenderingDelay() override { return RenderingDelay(); }
+
+ private:
+  MediaPipelineBackend::Delegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioDecoderDefault);
+};
+
+class MediaPipelineBackendDefault::VideoDecoderDefault
+    : public MediaPipelineBackend::VideoDecoder {
+ public:
+  VideoDecoderDefault() : delegate_(nullptr) {}
+  ~VideoDecoderDefault() override {}
+
+  void SetDelegate(MediaPipelineBackend::Delegate* delegate) {
+    delegate_ = delegate;
+  }
+
+  // MediaPipelineBackend::VideoDecoder implementation:
+  BufferStatus PushBuffer(DecryptContext* decrypt_context,
+                          CastDecoderBuffer* buffer) override {
+    if (buffer->end_of_stream())
+      delegate_->OnEndOfStream(this);
+    return MediaPipelineBackend::kBufferSuccess;
+  }
+
+  void GetStatistics(Statistics* statistics) override {}
+
+  bool SetConfig(const VideoConfig& config) override { return true; }
+
+ private:
+  MediaPipelineBackend::Delegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(VideoDecoderDefault);
+};
+
+MediaPipelineBackendDefault::MediaPipelineBackendDefault()
+    : running_(false),
+      rate_(1.0f),
+      audio_decoder_(nullptr),
+      video_decoder_(nullptr) {
+}
+
+MediaPipelineBackendDefault::~MediaPipelineBackendDefault() {
+  delete audio_decoder_;

[slan, 2015/10/06 19:34:00]

1) Since we already have //base deps, why not used scoped_ptr here?

2) If no scoped_ptr, please check that these are not nullptr before attempting
to delete them.

[kmackay, 2015/10/06 21:44:55]

deleting nullptr is extremely valid.

[slan, 2015/10/06 22:15:05]

TIL.

+  delete video_decoder_;
 }
 
-AudioPipelineDevice* MediaPipelineBackendDefault::GetAudio() {
-  if (!audio_)
-    audio_.reset(new AudioPipelineDeviceDefault(params_, GetClock()));
-  return audio_.get();
+MediaPipelineBackend::AudioDecoder*
+MediaPipelineBackendDefault::CreateAudioDecoder() {

[slan, 2015/10/06 19:34:00]

Don't the requirements state that the backend must provide 3+1 A/V decoders?
Shouldn't we be able to call this function 3+1 times before it DCHECKs or
something?

[kmackay, 2015/10/06 21:44:55]

The requirement is that the vendor media shlib is able to create 3+1
MediaPipelineBackend instances (one for synchronized audio+video, and 3 for just
audio). Maybe the header comments are poorly worded; I'll try to clarify.

[slan, 2015/10/06 22:15:05]

Ah much clearer, thanks!

+  DCHECK(!audio_decoder_);
+  audio_decoder_ = new AudioDecoderDefault();
+  return audio_decoder_;
+}
+
+MediaPipelineBackend::VideoDecoder*
+MediaPipelineBackendDefault::CreateVideoDecoder() {
+  DCHECK(!video_decoder_);
+  video_decoder_ = new VideoDecoderDefault();
+  return video_decoder_;
+}
+
+bool MediaPipelineBackendDefault::Initialize(Delegate* delegate) {
+  DCHECK(delegate);
+  if (audio_decoder_)
+    audio_decoder_->SetDelegate(delegate);
+  if (video_decoder_)
+    video_decoder_->SetDelegate(delegate);
+  return true;
+}
+
+bool MediaPipelineBackendDefault::Start(int64_t start_pts) {
+  DCHECK(!running_);
+  start_pts_ = base::TimeDelta::FromMicroseconds(start_pts);
+  start_clock_ = base::TimeTicks::Now();
+  running_ = true;
+  return true;
+}
+
+bool MediaPipelineBackendDefault::Stop() {
+  running_ = false;
+  start_pts_ = base::TimeDelta::FromMicroseconds(GetCurrentPts());

[slan, 2015/10/06 19:34:00]

You want to call this before setting running_ to false. Otherwise start_pts_
will not increment. In Pause() too.

[kmackay, 2015/10/06 21:44:55]

Done.

+  return true;
+}
+
+bool MediaPipelineBackendDefault::Pause() {
+  DCHECK(running_);
+  running_ = false;
+  start_pts_ = base::TimeDelta::FromMicroseconds(GetCurrentPts());
+  return true;
+}
+
+bool MediaPipelineBackendDefault::Resume() {
+  DCHECK(!running_);
+  running_ = true;
+  start_clock_ = base::TimeTicks::Now();
+  return true;
+}
+
+int64_t MediaPipelineBackendDefault::GetCurrentPts() {
+  if (!running_)
+    return start_pts_.InMicroseconds();
+
+  base::TimeTicks now = base::TimeTicks::Now();
+  base::TimeDelta interpolated_media_time =
+      start_pts_ + (now - start_clock_) * rate_;
+  return interpolated_media_time.InMicroseconds();
 }
 
-VideoPipelineDevice* MediaPipelineBackendDefault::GetVideo() {
-  if (!video_)
-    video_.reset(new VideoPipelineDeviceDefault(params_, GetClock()));
-  return video_.get();
+bool MediaPipelineBackendDefault::SetPlaybackRate(float rate) {
+  DCHECK(rate != 0);

[slan, 2015/10/06 19:34:00]

nit: rate > 0

[kmackay, 2015/10/06 21:44:55]

0 is potentially valid here.

[slan, 2015/10/06 22:15:05]

The comments in the header (pasted below) hold that it must be positive. Is
there a good use case for 0? I would think that pause should be used instead. 

Comment:
 // Sets the playback rate.  |rate| > 0. 

[kmackay, 2015/10/07 16:37:58]

Done.

+  start_pts_ = base::TimeDelta::FromMicroseconds(GetCurrentPts());
+  start_clock_ = base::TimeTicks::Now();
+  rate_ = rate;
+  return true;
 }
 
 }  // namespace media