Encrypted Media: Support Audio Decrypt-Only.

media/filters/audio_decoder_selector.cc

Index: media/filters/audio_decoder_selector.cc
diff --git a/media/filters/audio_decoder_selector.cc b/media/filters/audio_decoder_selector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..855f6add249450edeecb837dbf2e9720692759e2
--- /dev/null
+++ b/media/filters/audio_decoder_selector.cc
@@ -0,0 +1,153 @@
+// 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_decoder_selector.h"
+
+#include "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/logging.h"
+#include "base/message_loop_proxy.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/bind_to_loop.h"
+#include "media/base/demuxer_stream.h"
+#include "media/base/pipeline.h"
+#include "media/filters/decrypting_audio_decoder.h"
+#include "media/filters/decrypting_demuxer_stream.h"
+
+namespace media {
+
+AudioDecoderSelector::AudioDecoderSelector(
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    const AudioDecoderList& clear_decoders,
+    const SetDecryptorReadyCB& set_decryptor_ready_cb)
+    : message_loop_(message_loop),
+      clear_decoders_(clear_decoders),
+      set_decryptor_ready_cb_(set_decryptor_ready_cb),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
+      weak_this_(weak_ptr_factory_.GetWeakPtr()) {

[scherkus (not reviewing), 2012/12/13 23:39:07]

nit: if this is created on the same thread as SelectAudioDecoder() is called,
you can drop the weak_this_ and just have the factory and hand out weakptrs when
you base::Bind()

[xhwang, 2012/12/14 03:16:21]

Done.

+}
+
+AudioDecoderSelector::~AudioDecoderSelector() {}
+
+void AudioDecoderSelector::SelectAudioDecoder(
+    const scoped_refptr<DemuxerStream>& stream,
+    const StatisticsCB& statistics_cb,
+    const SelectDecoderCB& select_decoder_cb) {
+  DVLOG(2) << "SelectAudioDecoder()";
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(stream);
+
+  // Make sure the |selected_decoder_cb| on a different execution stack.
+  select_decoder_cb_ = BindToCurrentLoop(select_decoder_cb);
+
+  const AudioDecoderConfig& config = stream->audio_decoder_config();
+  if (!config.IsValidConfig()) {
+    DLOG(ERROR) << "Invalid audio stream config.";
+    base::ResetAndReturn(&select_decoder_cb_).Run(NULL, NULL);
+    return;
+  }
+
+  input_stream_ = stream;

[scherkus (not reviewing), 2012/12/13 23:39:07]

nit: your call, but I think we can be fancy here and bind stream + stats cb for
each callback and keep passing it through instead of having member variables

up to you if you find it's clearer / less stateful

[xhwang, 2012/12/14 03:16:21]

hmm, I'd keep the current way.. Passing them around seems not as clean...

+  statistics_cb_ = statistics_cb;
+
+  if (!config.is_encrypted()) {
+    if (clear_decoders_.empty()) {
+      DLOG(ERROR) << "No audio decoder can be used to decode the input stream.";
+      base::ResetAndReturn(&select_decoder_cb_).Run(NULL, NULL);
+      return;
+    }
+
+    InitializeNextClearDecoder();
+    return;
+  }
+
+  // This could happen if Encrypted Media Extension (EME) is not enabled.
+  if (set_decryptor_ready_cb_.is_null()) {
+    base::ResetAndReturn(&select_decoder_cb_).Run(NULL, NULL);
+    return;
+  }
+
+  audio_decoder_ = new DecryptingAudioDecoder(message_loop_,
+                                              set_decryptor_ready_cb_);
+
+  audio_decoder_->Initialize(
+      input_stream_,
+      BindToCurrentLoop(base::Bind(

[scherkus (not reviewing), 2012/12/13 23:39:07]

hmmm... we really shouldn't be so paranoid about binding everything

AFAIK all our audio decoders run on the same thread. are you finding this isn't
the case?

[xhwang, 2012/12/14 03:16:21]

Now FFmpegAudioDecoder and AudioDecoderImpl all run on the pipeline thread,
correct? In that cast, FFmpegAudioDecoder can call the callback on the same
execution stack. 
http://code.google.com/searchframe#OAMlx_jo-ck/src/media/filters/ffmpeg_audio...

I want to prevent the reentrance caused by that. This is also related to the
discussion of who should post the task, the caller or the callee?

+          &AudioDecoderSelector::DecryptingAudioDecoderInitDone, weak_this_)),
+      statistics_cb_);
+}
+
+void AudioDecoderSelector::DecryptingAudioDecoderInitDone(
+    PipelineStatus status) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+
+  if (status == PIPELINE_OK) {
+    clear_decoders_.clear();
+    base::ResetAndReturn(&select_decoder_cb_).Run(audio_decoder_, NULL);
+    return;
+  }
+
+  audio_decoder_ = NULL;
+
+  if (clear_decoders_.empty()) {
+    DLOG(ERROR) << "No audio decoder can be used to decode the input stream.";
+    base::ResetAndReturn(&select_decoder_cb_).Run(NULL, NULL);
+    return;
+  }
+
+  decrypted_stream_ = new DecryptingDemuxerStream(
+      message_loop_, set_decryptor_ready_cb_);
+
+  decrypted_stream_->Initialize(
+      input_stream_,
+      BindToCurrentLoop(base::Bind(
+          &AudioDecoderSelector::DecryptingDemuxerStreamInitDone, weak_this_)));
+}
+
+void AudioDecoderSelector::DecryptingDemuxerStreamInitDone(
+    PipelineStatus status) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+
+  if (status != PIPELINE_OK) {
+    decrypted_stream_ = NULL;
+    base::ResetAndReturn(&select_decoder_cb_).Run(NULL, NULL);
+    return;
+  }
+
+  DCHECK(!decrypted_stream_->audio_decoder_config().is_encrypted());
+  input_stream_ = decrypted_stream_;
+  InitializeNextClearDecoder();
+}
+
+void AudioDecoderSelector::InitializeNextClearDecoder() {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(!clear_decoders_.empty());
+
+  audio_decoder_ = clear_decoders_.front();
+  clear_decoders_.pop_front();
+  DCHECK(audio_decoder_);
+  audio_decoder_->Initialize(
+      input_stream_,
+      BindToCurrentLoop(base::Bind(
+          &AudioDecoderSelector::ClearDecoderInitDone, weak_this_)),
+      statistics_cb_);
+}
+
+void AudioDecoderSelector::ClearDecoderInitDone(PipelineStatus status) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+
+  if (status != PIPELINE_OK) {
+    if (!clear_decoders_.empty())
+      InitializeNextClearDecoder();
+    else
+      base::ResetAndReturn(&select_decoder_cb_).Run(NULL, NULL);
+    return;
+  }
+
+  clear_decoders_.clear();
+  base::ResetAndReturn(&select_decoder_cb_).Run(audio_decoder_,
+                                                decrypted_stream_);
+}
+
+}  // namespace media