Android: Propagate sample rate change to audio decoder job

media/base/android/audio_decoder_job.cc

 // Copyright 2013 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/audio_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/threading/thread.h"
 #include "media/base/android/media_codec_bridge.h"
@@ skipping 22 matching lines @@
     g_audio_decoder_thread = LAZY_INSTANCE_INITIALIZER;
 
 AudioDecoderJob::AudioDecoderJob(
     const base::Closure& request_data_cb,
     const base::Closure& on_demuxer_config_changed_cb)
     : MediaDecoderJob(g_audio_decoder_thread.Pointer()->message_loop_proxy(),
                       request_data_cb,
                       on_demuxer_config_changed_cb),
       audio_codec_(kUnknownAudioCodec),
       num_channels_(0),
-      sampling_rate_(0),
+      config_sampling_rate_(0),
       volume_(-1.0),
-      bytes_per_frame_(0) {
+      bytes_per_frame_(0),
+      output_sampling_rate_(0) {
 }
 
 AudioDecoderJob::~AudioDecoderJob() {}
 
 bool AudioDecoderJob::HasStream() const {
   return audio_codec_ != kUnknownAudioCodec;
 }
 
 void AudioDecoderJob::SetDemuxerConfigs(const DemuxerConfigs& configs) {
   // TODO(qinmin): split DemuxerConfig for audio and video separately so we
   // can simply store the stucture here.
   audio_codec_ = configs.audio_codec;
   num_channels_ = configs.audio_channels;
-  sampling_rate_ = configs.audio_sampling_rate;
+  config_sampling_rate_ = configs.audio_sampling_rate;
   set_is_content_encrypted(configs.is_audio_encrypted);
   audio_extra_data_ = configs.audio_extra_data;
   bytes_per_frame_ = kBytesPerAudioOutputSample * num_channels_;
+  if (!media_codec_bridge_) {
+    output_sampling_rate_ = config_sampling_rate_;
+  }
 }
 
 void AudioDecoderJob::SetVolume(double volume) {
   volume_ = volume;
   SetVolumeInternal();
 }
 
 void AudioDecoderJob::SetBaseTimestamp(base::TimeDelta base_timestamp) {
   DCHECK(!is_decoding());
   base_timestamp_ = base_timestamp;
   if (audio_timestamp_helper_)
     audio_timestamp_helper_->SetBaseTimestamp(base_timestamp_);
 }
 
+void AudioDecoderJob::ResetTimestampHelper() {
+  if (audio_timestamp_helper_)
+    base_timestamp_ = audio_timestamp_helper_->GetTimestamp();
+  audio_timestamp_helper_.reset(
+      new AudioTimestampHelper(output_sampling_rate_));
+  audio_timestamp_helper_->SetBaseTimestamp(base_timestamp_);
+}
+
 void AudioDecoderJob::ReleaseOutputBuffer(
     int output_buffer_index,
     size_t size,
     bool render_output,
     base::TimeDelta current_presentation_timestamp,
     const ReleaseOutputCompletionCallback& callback) {
   render_output = render_output && (size != 0u);
   if (render_output) {
     int64 head_position = (static_cast<AudioCodecBridge*>(
         media_codec_bridge_.get()))->PlayOutputBuffer(
@@ skipping 15 matching lines @@
 }
 
 bool AudioDecoderJob::ComputeTimeToRender() const {
   return false;
 }
 
 bool AudioDecoderJob::AreDemuxerConfigsChanged(
     const DemuxerConfigs& configs) const {
   return audio_codec_ != configs.audio_codec ||
      num_channels_ != configs.audio_channels ||
-     sampling_rate_ != configs.audio_sampling_rate ||
+     config_sampling_rate_ != configs.audio_sampling_rate ||
      is_content_encrypted() != configs.is_audio_encrypted ||
      audio_extra_data_.size() != configs.audio_extra_data.size() ||
      !std::equal(audio_extra_data_.begin(),
                  audio_extra_data_.end(),
                  configs.audio_extra_data.begin());
 }
 
 bool AudioDecoderJob::CreateMediaCodecBridgeInternal() {
   media_codec_bridge_.reset(AudioCodecBridge::Create(audio_codec_));
   if (!media_codec_bridge_)
     return false;
 
   if (!(static_cast<AudioCodecBridge*>(media_codec_bridge_.get()))->Start(
-      audio_codec_, sampling_rate_, num_channels_, &audio_extra_data_[0],
+      audio_codec_, config_sampling_rate_, num_channels_, &audio_extra_data_[0],
       audio_extra_data_.size(), true, GetMediaCrypto().obj())) {
     media_codec_bridge_.reset();
     return false;
   }
 
   SetVolumeInternal();
 
   // Need to pass the base timestamp to the new decoder.
-  if (audio_timestamp_helper_)
-    base_timestamp_ = audio_timestamp_helper_->GetTimestamp();
-  audio_timestamp_helper_.reset(new AudioTimestampHelper(sampling_rate_));
-  audio_timestamp_helper_->SetBaseTimestamp(base_timestamp_);
+  ResetTimestampHelper();
+
   return true;
 }
 
 void AudioDecoderJob::SetVolumeInternal() {
   if (media_codec_bridge_) {
     static_cast<AudioCodecBridge*>(media_codec_bridge_.get())->SetVolume(
         volume_);
   }
 }
 
+bool AudioDecoderJob::UpdateOutputFormat() {
+  if (!media_codec_bridge_)
+    return false;
+
+  int old_sampling_rate = output_sampling_rate_;
+  media_codec_bridge_->GetOutputSamplingRate(&output_sampling_rate_);
+  if (output_sampling_rate_ == old_sampling_rate)
+    return false;
+
+  ResetTimestampHelper();

[gunsch, 2015/01/12 16:30:51]

Thought: it might also be a good idea to call reconfigureAudioTrack from here.

With this addition and the previous CL in MediaCodecBridge.java, there are now
two paths for reconfiguring AudioDecoderJob on a STATUS_FORMAT_CHANGED:

1) (this class) UpdateOutputFormat --> ResetTimestampHelper
2) (MediaCodecBridge.java) dequeueOutputBuffer --> reconfigureAudioTrack

It would probably be better to essentially revert the changes to
dequeueOutputBuffer from the previous CL, add a @CalledFromNative to
reconfigureAudioTrack, and also invoke that here.

[kjoswiak, 2015/01/12 19:44:48]

Hmm, maybe. I would have to add/change codepath to handle error condition of
failing the reconfigure. Will look into if I can do this cleanly

+
+  return true;
+}
+
 }  // namespace media