MediaCodecPlayer implementation (stage 4 - preroll)

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& preroll_done_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,
+                        preroll_done_cb,
                         stop_done_cb,
                         error_cb,
                         "AudioDecoder"),
       volume_(-1.0),
       bytes_per_frame_(0),
       output_sampling_rate_(0),
       frame_count_(0),
+#ifndef NDEBUG
+      num_postponed_buffers_(0),
+#endif
       update_current_time_cb_(update_current_time_cb) {
 }
 
 MediaCodecAudioDecoder::~MediaCodecAudioDecoder() {
   DVLOG(1) << "AudioDecoder::~AudioDecoder()";
   ReleaseDecoderResources();
 }
 
 const char* MediaCodecAudioDecoder::class_name() const {
   return "AudioDecoder";
@@ skipping 13 matching lines @@
   configs_ = configs;
   if (!media_codec_bridge_)
     output_sampling_rate_ = configs.audio_sampling_rate;
 }
 
 void MediaCodecAudioDecoder::Flush() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   MediaCodecDecoder::Flush();
   frame_count_ = 0;
+
+#ifndef NDEBUG
+  // Maintain the number of postponed buffers corresponding to the Java side.
+  num_postponed_buffers_ = 0;
+#endif
+}
+
+void MediaCodecAudioDecoder::ReleaseMediaCodec() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+  MediaCodecDecoder::ReleaseMediaCodec();
+
+#ifndef NDEBUG
+  // Maintain the number of postponed buffers corresponding to the Java side.
+  num_postponed_buffers_ = 0;
+#endif
 }
 
 void MediaCodecAudioDecoder::SetVolume(double volume) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << volume;
 
   volume_ = volume;
   SetVolumeInternal();
 }
@@ skipping 69 matching lines @@
   DCHECK(media_codec_bridge_);
 
   int old_sampling_rate = output_sampling_rate_;
   output_sampling_rate_ = media_codec_bridge_->GetOutputSamplingRate();
   if (output_sampling_rate_ != old_sampling_rate)
     ResetTimestampHelper();
 }
 
 void MediaCodecAudioDecoder::Render(int buffer_index,
                                     size_t size,
-                                    bool render_output,
+                                    RenderMode render_mode,
                                     base::TimeDelta pts,
                                     bool eos_encountered) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
-  DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts;
+  DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts << " "
+           << AsString(render_mode);
 
-  render_output = render_output && (size != 0u);
+  const bool do_play = (render_mode != kRenderSkip);
 
-  if (render_output) {
+  if (do_play) {
+    AudioCodecBridge* audio_codec =
+        static_cast<AudioCodecBridge*>(media_codec_bridge_.get());
+
+    DCHECK(audio_codec);
+
+    const bool postpone = (render_mode == kRenderAfterPreroll);
+
+#ifndef NDEBUG
+    // MediaCodecBrdge.java only keeps one buffer postponed buffer, but we

[qinmin, 2015/08/03 21:25:15]

I don't think this is true with you CL "keeps one buffer postponed buffer"

[Tima Vaisburd, 2015/08/03 22:49:05]

I kept only one buffer on Java side instead of an array of buffers, put assert
there and removed DCHECKs here on C++ side.

+    // increase |frame_count_| every time we call PlayOutputBuffer().
+    // Check that we are in balance with MediaCodecBrdge.java.
+    // TODO(timav): It seems better to let Java side keep an array of
+    // postponed buffers and drop this check.
+    if (postpone)
+      ++num_postponed_buffers_;
+    else
+      num_postponed_buffers_ = 0;
+    DCHECK_GE(1, num_postponed_buffers_);
+#endif
+
     int64 head_position =
-        (static_cast<AudioCodecBridge*>(media_codec_bridge_.get()))
-            ->PlayOutputBuffer(buffer_index, size);
+        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);
-    int64 frames_to_play = frame_count_ - head_position;
-    DCHECK_GE(frames_to_play, 0);
 
-    base::TimeDelta last_buffered = audio_timestamp_helper_->GetTimestamp();
-    base::TimeDelta now_playing =
-        last_buffered -
-        audio_timestamp_helper_->GetFrameDuration(frames_to_play);
+    if (!postpone) {
+      int64 frames_to_play = frame_count_ - head_position;
 
-    DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts
-             << " will play: [" << now_playing << "," << last_buffered << "]";
+      // TODO(timav): remove this DVLOG after more testing.
+      if (frames_to_play < 0) {
+        DVLOG(0) << class_name() << "::" << __FUNCTION__ << " pts:" << pts
+                 << " frame_count_ < head_position (" << frame_count_ << " < "
+                 << head_position << ")"
+                 << " new_frames_count:" << new_frames_count;
+      }
+      DCHECK_GE(frames_to_play, 0);
 
-    media_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(update_current_time_cb_, now_playing, last_buffered));
+      base::TimeDelta last_buffered = audio_timestamp_helper_->GetTimestamp();
+      base::TimeDelta now_playing =
+          last_buffered -
+          audio_timestamp_helper_->GetFrameDuration(frames_to_play);
+
+      DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts
+               << " will play: [" << now_playing << "," << last_buffered << "]";
+
+      media_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(update_current_time_cb_, now_playing, last_buffered));
+    }
   }
 
   media_codec_bridge_->ReleaseOutputBuffer(buffer_index, false);
 
   CheckLastFrame(eos_encountered, false);  // no delayed tasks
 }
 
 void MediaCodecAudioDecoder::SetVolumeInternal() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
@@ skipping 11 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