MediaCodecPlayer implementation (stage 5 - reconfiguration)

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;
 
 // Fake buffer index that refers to pending buffer.
 const int kPendingBufferIndex = -1;
 }
 
 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& error_cb,
     const SetTimeCallback& update_current_time_cb)
     : MediaCodecDecoder(media_task_runner,
                         request_data_cb,
                         starvation_cb,
+                        decoder_drained_cb,
                         stop_done_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() {
   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) {
-  DCHECK(media_task_runner_->BelongsToCurrentThread());
-
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << configs;
 
   configs_ = configs;
   if (!media_codec_bridge_)
     output_sampling_rate_ = configs.audio_sampling_rate;
 }
 
 void MediaCodecAudioDecoder::Flush() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
@@ skipping 19 matching lines @@
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << __FUNCTION__ << " " << base_timestamp;
 
   base_timestamp_ = base_timestamp;
   if (audio_timestamp_helper_)
     audio_timestamp_helper_->SetBaseTimestamp(base_timestamp_);
 }
 
 bool MediaCodecAudioDecoder::IsCodecReconfigureNeeded(
-    const DemuxerConfigs& curr,
     const DemuxerConfigs& next) const {
-  return curr.audio_codec != next.audio_codec ||
-         curr.audio_channels != next.audio_channels ||
-         curr.audio_sampling_rate != next.audio_sampling_rate ||
+  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 ||
-         curr.audio_extra_data.size() != next.audio_extra_data.size() ||
-         !std::equal(curr.audio_extra_data.begin(), curr.audio_extra_data.end(),
+         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() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   if (configs_.audio_codec == kUnknownAudioCodec) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
@@ skipping 61 matching lines @@
     AudioCodecBridge* audio_codec =
         static_cast<AudioCodecBridge*>(media_codec_bridge_.get());
 
     DCHECK(audio_codec);
 
     const bool postpone = (render_mode == kRenderAfterPreroll);
 
     int64 head_position =
         audio_codec->PlayOutputBuffer(buffer_index, size, postpone);
 
-    DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts
-             << (postpone ? " POSTPONE" : "")
-             << " head_position:" << head_position;
-
     size_t new_frames_count = size / bytes_per_frame_;
     frame_count_ += new_frames_count;
     audio_timestamp_helper_->AddFrames(new_frames_count);
 
-    if (!postpone) {
+    if (postpone) {
+      DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts
+               << " POSTPONE";
+    } else {
       int64 frames_to_play = frame_count_ - head_position;
 
       DCHECK_GE(frames_to_play, 0) << class_name() << "::" << __FUNCTION__
                                    << " pts:" << pts
                                    << " frame_count_:" << frame_count_
                                    << " head_position:" << head_position;
 
       base::TimeDelta last_buffered = audio_timestamp_helper_->GetTimestamp();
       base::TimeDelta now_playing =
           last_buffered -
@@ skipping 30 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