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(
+    const base::Closure& config_changed_cb) {
+  if (!media_codec_bridge_)
+    return true;
+
+  int old_sampling_rate = output_sampling_rate_;
+  media_codec_bridge_->GetOutputSamplingRate(&output_sampling_rate_);
+  if (output_sampling_rate_ == old_sampling_rate)
+    return true;
+  if (!media_codec_bridge_->ReconfigureAudioTrack())
+    return false;
+  ResetTimestampHelper();

[kjoswiak, 2015/01/16 23:14:56]

This function call is still not threadsafe with ReleaseOutputBuffer(), and they
now run on different threads. Thinking about best solution, if nothing clever
comes to mind will move this call back to decoder thread

What would the policy be for putting a lock around object? Is it ok with ui
thread?

[kjoswiak, 2015/01/17 01:13:20]

Ehh I think it's fine since there can only be one decode running anyway. Ready
for review

+  config_changed_cb.Run();
+  return true;
+}
+
 }  // namespace media