MediaCodecPlayer implementation - stage 7 (DRM)

media/base/android/media_codec_audio_decoder.cc

 // Copyright 2015 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/base/android/media_codec_audio_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/demuxer_stream.h"
 
 namespace {
 
 // Use 16bit PCM for audio output. Keep this value in sync with the output
 // format we passed to AudioTrack in MediaCodecBridge.
 const int kBytesPerAudioOutputSample = 2;
 }
 
 namespace media {
 
 MediaCodecAudioDecoder::MediaCodecAudioDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const base::Closure& request_data_cb,
     const base::Closure& starvation_cb,
     const base::Closure& decoder_drained_cb,
     const base::Closure& stop_done_cb,
+    const base::Closure& key_required_cb,
     const base::Closure& error_cb,
     const SetTimeCallback& update_current_time_cb)
     : MediaCodecDecoder(media_task_runner,
                         request_data_cb,
                         starvation_cb,
                         decoder_drained_cb,
                         stop_done_cb,
+                        key_required_cb,
                         error_cb,
                         "AudioDecoder"),
       volume_(-1.0),
       bytes_per_frame_(0),
       output_sampling_rate_(0),
       frame_count_(0),
       update_current_time_cb_(update_current_time_cb) {
 }
 
 MediaCodecAudioDecoder::~MediaCodecAudioDecoder() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "AudioDecoder::~AudioDecoder()";
   ReleaseDecoderResources();
 }
 
 const char* MediaCodecAudioDecoder::class_name() const {
   return "AudioDecoder";
 }
 
 bool MediaCodecAudioDecoder::HasStream() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   return configs_.audio_codec != kUnknownAudioCodec;
 }
 
 void MediaCodecAudioDecoder::SetDemuxerConfigs(const DemuxerConfigs& configs) {
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << configs;

[xhwang, 2015/09/30 18:07:53]

Same as the comment in the other CL, usually you don't need the class_name() in
the log. But it's up to you and can be in a separate CL.

[Tima Vaisburd, 2015/09/30 23:00:50]

The class_name() is not an equivalent of the file name here, I used it more as
the stream type. And it is a virtual method useful in the base class
MediaCodecDecoder where the file name won't tell you the real type.

[xhwang, 2015/10/01 00:04:39]

I see. But won't the file name (media_codec_audio_decoder.cc) be sufficient
here?

[Tima Vaisburd, 2015/10/01 00:36:06]

Here - yes. I'd say it is nice to have this form here for consistency, because
many such calls are made in the base class.

 
   configs_ = configs;
   if (!media_codec_bridge_)
     output_sampling_rate_ = configs.audio_sampling_rate;
 }
 
+bool MediaCodecAudioDecoder::IsContentEncrypted() const {

[xhwang, 2015/09/30 18:07:53]

Can this be called before |configs_| is set? If not, should we DCHECK that this
is only called after |configs_| is set?

[Tima Vaisburd, 2015/09/30 23:00:50]

No, the state machine should take care of this. Added DCHECK.

+  return configs_.is_audio_encrypted;
+}
+
 void MediaCodecAudioDecoder::ReleaseDecoderResources() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   DoEmergencyStop();
 
   ReleaseMediaCodec();
 }
 
 void MediaCodecAudioDecoder::Flush() {
@@ skipping 24 matching lines @@
 }
 
 bool MediaCodecAudioDecoder::IsCodecReconfigureNeeded(
     const DemuxerConfigs& next) const {
   if (always_reconfigure_for_tests_)
     return true;
 
   return configs_.audio_codec != next.audio_codec ||
          configs_.audio_channels != next.audio_channels ||
          configs_.audio_sampling_rate != next.audio_sampling_rate ||
-         next.is_audio_encrypted != next.is_audio_encrypted ||
+         configs_.is_audio_encrypted != next.is_audio_encrypted ||
          configs_.audio_extra_data.size() != next.audio_extra_data.size() ||
          !std::equal(configs_.audio_extra_data.begin(),
                      configs_.audio_extra_data.end(),
                      next.audio_extra_data.begin());
 }
 
-MediaCodecDecoder::ConfigStatus MediaCodecAudioDecoder::ConfigureInternal() {
+MediaCodecDecoder::ConfigStatus MediaCodecAudioDecoder::ConfigureInternal(
+    jobject media_crypto) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   if (configs_.audio_codec == kUnknownAudioCodec) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << " configuration parameters are required";
     return kConfigFailure;
   }
 
   media_codec_bridge_.reset(AudioCodecBridge::Create(configs_.audio_codec));
   if (!media_codec_bridge_)
     return kConfigFailure;
 
   if (!(static_cast<AudioCodecBridge*>(media_codec_bridge_.get()))
            ->Start(
                configs_.audio_codec,
                configs_.audio_sampling_rate,
                configs_.audio_channels,
                &configs_.audio_extra_data[0],
                configs_.audio_extra_data.size(),
                configs_.audio_codec_delay_ns,
                configs_.audio_seek_preroll_ns,
                true,
-               GetMediaCrypto().obj())) {
+               media_crypto)) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << " failed: cannot start audio codec";
 
     media_codec_bridge_.reset();
     return kConfigFailure;
   }
 
   DVLOG(0) << class_name() << "::" << __FUNCTION__ << " succeeded";
 
   SetVolumeInternal();
@@ skipping 104 matching lines @@
   if (audio_timestamp_helper_)
     base_timestamp_ = audio_timestamp_helper_->GetTimestamp();
 
   audio_timestamp_helper_.reset(
       new AudioTimestampHelper(configs_.audio_sampling_rate));
 
   audio_timestamp_helper_->SetBaseTimestamp(base_timestamp_);
 }
 
 }  // namespace media