Encrypted Media: Support Audio Decrypt-Only.

media/filters/audio_renderer_impl.cc

 // Copyright (c) 2012 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/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "media/audio/audio_util.h"
 #include "media/base/audio_splicer.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_switches.h"
+#include "media/filters/audio_decoder_selector.h"
+#include "media/filters/decrypting_demuxer_stream.h"
 
 namespace media {
 
-AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
+AudioRendererImpl::AudioRendererImpl(
+    media::AudioRendererSink* sink,
+    const SetDecryptorReadyCB& set_decryptor_ready_cb)
     : sink_(sink),
+      set_decryptor_ready_cb_(set_decryptor_ready_cb),
       state_(kUninitialized),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       audio_time_buffered_(kNoTimestamp()),
       current_time_(kNoTimestamp()),
       underflow_disabled_(false),
       preroll_aborted_(false),
       actual_frames_per_buffer_(0) {
   // We're created on the render thread, but this thread checker is for another.
@@ skipping 48 matching lines @@
 }
 
 void AudioRendererImpl::DoPause() {
   DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   DCHECK(sink_);
   sink_->Pause(false);
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
   DCHECK(pipeline_thread_checker_.CalledOnValidThread());
+
+  if (decrypting_demuxer_stream_) {
+    decrypting_demuxer_stream_->Reset(base::Bind(
+        &AudioRendererImpl::ResetDecoder, this, callback));
+    return;
+  }
+
+  decoder_->Reset(callback);
+}
+
+void AudioRendererImpl::ResetDecoder(const base::Closure& callback) {
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   decoder_->Reset(callback);
 }
 
 void AudioRendererImpl::Stop(const base::Closure& callback) {
   DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (sink_) {
     sink_->Stop();
     sink_ = NULL;
@@ skipping 37 matching lines @@
 
     // |algorithm_| will request more reads.
     algorithm_->FlushBuffers();
     earliest_end_time_ = base::Time::Now();
   }
 
   // Pause and flush the stream when we preroll to a new location.
   sink_->Pause(true);
 }
 
-void AudioRendererImpl::Initialize(const scoped_refptr<DemuxerStream>& stream,
-                                   const AudioDecoderList& decoders,
-                                   const PipelineStatusCB& init_cb,
-                                   const StatisticsCB& statistics_cb,
-                                   const base::Closure& underflow_cb,
-                                   const TimeCB& time_cb,
-                                   const base::Closure& ended_cb,
-                                   const base::Closure& disabled_cb,
-                                   const PipelineStatusCB& error_cb) {
+void AudioRendererImpl::Initialize(
+    const scoped_refptr<DemuxerStream>& stream,
+    const AudioDecoderList& decoders,
+    const PipelineStatusCB& init_cb,
+    const StatisticsCB& statistics_cb,
+    const base::Closure& underflow_cb,
+    const TimeCB& time_cb,
+    const base::Closure& ended_cb,
+    const base::Closure& disabled_cb,
+    const PipelineStatusCB& error_cb) {
   DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   DCHECK(stream);
   DCHECK(!decoders.empty());
   DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!underflow_cb.is_null());
   DCHECK(!time_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!disabled_cb.is_null());
   DCHECK(!error_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   DCHECK(sink_);
 
   init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
   underflow_cb_ = underflow_cb;
   time_cb_ = time_cb;
   ended_cb_ = ended_cb;
   disabled_cb_ = disabled_cb;
   error_cb_ = error_cb;
 
-  scoped_ptr<AudioDecoderList> decoder_list(new AudioDecoderList(decoders));
-  InitializeNextDecoder(stream, decoder_list.Pass());
+  scoped_ptr<AudioDecoderSelector> decoder_selector(
+      new AudioDecoderSelector(base::MessageLoopProxy::current(),
+                               decoders,
+                               set_decryptor_ready_cb_));
+
+  // To avoid calling |decoder_selector| methods and passing ownership of
+  // |decoder_selector| in the same line.
+  AudioDecoderSelector* decoder_selector_ptr = decoder_selector.get();
+
+  decoder_selector_ptr->SelectAudioDecoder(
+      stream,
+      statistics_cb,
+      base::Bind(&AudioRendererImpl::OnDecoderSelected, this,
+                 base::Passed(&decoder_selector)));
 }
 
-void AudioRendererImpl::InitializeNextDecoder(
-    const scoped_refptr<DemuxerStream>& demuxer_stream,
-    scoped_ptr<AudioDecoderList> decoders) {
-  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
-  DCHECK(!decoders->empty());
-
-  scoped_refptr<AudioDecoder> decoder = decoders->front();
-  decoders->pop_front();
-
-  DCHECK(decoder);
-  decoder_ = decoder;
-  decoder->Initialize(
-      demuxer_stream, BindToLoop(base::MessageLoopProxy::current(), base::Bind(
-          &AudioRendererImpl::OnDecoderInitDone, this, demuxer_stream,
-          base::Passed(&decoders))),
-      statistics_cb_);
-}
-
-void AudioRendererImpl::OnDecoderInitDone(
-    const scoped_refptr<DemuxerStream>& demuxer_stream,
-    scoped_ptr<AudioDecoderList> decoders,
-    PipelineStatus status) {
+void AudioRendererImpl::OnDecoderSelected(
+    scoped_ptr<AudioDecoderSelector> decoder_selector,
+    const scoped_refptr<AudioDecoder>& selected_decoder,
+    const scoped_refptr<DecryptingDemuxerStream>& decrypting_demuxer_stream) {
   DCHECK(pipeline_thread_checker_.CalledOnValidThread());
 
   if (state_ == kStopped) {
     DCHECK(!sink_);
     return;
   }
 
-  if (!decoders->empty() && status == DECODER_ERROR_NOT_SUPPORTED) {
-    InitializeNextDecoder(demuxer_stream, decoders.Pass());
+  if (!selected_decoder) {
+    base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  if (status != PIPELINE_OK) {
-    base::ResetAndReturn(&init_cb_).Run(status);
-    return;
-  }
+  decoder_ = selected_decoder;
+  decrypting_demuxer_stream_ = decrypting_demuxer_stream;
 
   int sample_rate = decoder_->samples_per_second();
   int buffer_size = GetHighLatencyOutputBufferSize(sample_rate);
   AudioParameters::Format format = AudioParameters::AUDIO_PCM_LINEAR;
 
   // On Windows and Mac we can use the low latency pipeline because they provide
   // accurate and smooth delay information.  On other platforms like Linux there
   // are jitter issues.
   // TODO(dalecurtis): Fix bugs: http://crbug.com/138098 http://crbug.com/32757
 #if defined(OS_WIN) || defined(OS_MAC)
@@ skipping 394 matching lines @@
     case kUnderflow:
     case kRebuffering:
     case kStopped:
       if (status != PIPELINE_OK)
         error_cb_.Run(status);
       return;
   }
 }
 
 }  // namespace media