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_);

[qinmin, 2015/01/21 21:43:56]

what is the max timestamp here? the new audio_timestamp_helper_ doesn't inherit
the max timestamp from the old one

[kjoswiak, 2015/01/21 22:53:11]

What do you mean?

We preserve storage of time by transferring over the base timestamp, so
computation of max_timestamp as we pass up callback will be still be correct.

Also, if referring to loss of frame_count information, its alright (actually,
required) since we recreate the audio track, and new track will have head
position of 0.

[kjoswiak, 2015/01/21 23:00:47]

Clarification: We don't TRANSFER base timestamp, we set new one to be current
time at point of config change. ALSO: why is base_timestamp_ a member variable?
We don't seem to ever actually read from it, only use it as storage (I could see
how maybe, if we did use this, it could be improper to drop that information. I
figured it existed to be in sync with helper however, so I kept things like
this)

[qinmin, 2015/01/22 00:07:45]

Suppose we got the following situation:
audioTrack has buffered 10 seconds of data, and the current presentation
timestep is 5 seconds, then audio_timestamp_helper_ should be  (5,15).
Now the next audio chunk came in, it reported a format change. Suppose 1 second
has passed since the last chunk has been decoded,
the current presentation timestamp should be 6. So we reset the AudioTrack and
we lose all the data from 6 seconds to 15 seconds, and we create a new
AudioTimeStampHelper with (6, 6).
Now when we decode the next audio chunk, the audio_timestamp_helper will think
that the new frame should begin at 6 second, but actually that frame is for the
15th second. And we will accumulate those errors whenever a format change
happens.
 

+}
+
 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_);
   }
 }
 
+void AudioDecoderJob::GotOutputFormatChanged() {
+  if (!media_codec_bridge_)
+    return;
+
+  int old_sampling_rate = output_sampling_rate_;
+  output_sampling_rate_ = media_codec_bridge_->GetOutputSamplingRate();
+  if (output_sampling_rate_ != old_sampling_rate)
+    ResetTimestampHelper();
+}
+
 }  // namespace media