Fix an issue that audio and video may ran out of sync

media/base/android/media_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/media_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 62 matching lines @@
 
   base::Closure done_cb = base::ResetAndReturn(&on_data_received_cb_);
 
   // If this data request is for the inactive chunk, or |on_data_received_cb_|
   // was set to null by ClearData() or Release(), do nothing.
   if (done_cb.is_null())
     return;
 
   if (stop_decode_pending_) {
     DCHECK(is_decoding());
-    OnDecodeCompleted(MEDIA_CODEC_STOPPED, kNoTimestamp(), 0);
+    OnDecodeCompleted(MEDIA_CODEC_STOPPED, kNoTimestamp(), kNoTimestamp());
     return;
   }
 
   done_cb.Run();
 }
 
 void MediaDecoderJob::Prefetch(const base::Closure& prefetch_cb) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(on_data_received_cb_.is_null());
   DCHECK(decode_cb_.is_null());
@@ skipping 174 matching lines @@
 
   RequestCurrentChunkIfEmpty();
   const AccessUnit& access_unit = CurrentAccessUnit();
   // If the first access unit is a config change, request the player to dequeue
   // the input buffer again so that it can request config data.
   if (access_unit.status == DemuxerStream::kConfigChanged) {
     ui_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&MediaDecoderJob::OnDecodeCompleted,
                                          base::Unretained(this),
                                          MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER,
-                                         kNoTimestamp(),
-                                         0));
+                                         kNoTimestamp(), kNoTimestamp()));
     return;
   }
 
   decoder_task_runner_->PostTask(FROM_HERE, base::Bind(
       &MediaDecoderJob::DecodeInternal, base::Unretained(this),
       access_unit,
       start_time_ticks, start_presentation_timestamp, needs_flush_,
       media::BindToCurrentLoop(base::Bind(
           &MediaDecoderJob::OnDecodeCompleted, base::Unretained(this)))));
   needs_flush_ = false;
 }
 
 void MediaDecoderJob::DecodeInternal(
     const AccessUnit& unit,
     base::TimeTicks start_time_ticks,
     base::TimeDelta start_presentation_timestamp,
     bool needs_flush,
     const MediaDecoderJob::DecoderCallback& callback) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("media", __FUNCTION__);
 
   if (needs_flush) {
     DVLOG(1) << "DecodeInternal needs flush.";
     input_eos_encountered_ = false;
     output_eos_encountered_ = false;
     MediaCodecStatus reset_status = media_codec_bridge_->Reset();
     if (MEDIA_CODEC_OK != reset_status) {
-      callback.Run(reset_status, kNoTimestamp(), 0);
+      callback.Run(reset_status, kNoTimestamp(), kNoTimestamp());
       return;
     }
   }
 
   // Once output EOS has occurred, we should not be asked to decode again.
   // MediaCodec has undefined behavior if similarly asked to decode after output
   // EOS.
   DCHECK(!output_eos_encountered_);
 
   // For aborted access unit, just skip it and inform the player.
   if (unit.status == DemuxerStream::kAborted) {
     // TODO(qinmin): use a new enum instead of MEDIA_CODEC_STOPPED.
-    callback.Run(MEDIA_CODEC_STOPPED, kNoTimestamp(), 0);
+    callback.Run(MEDIA_CODEC_STOPPED, kNoTimestamp(), kNoTimestamp());
     return;
   }
 
   if (skip_eos_enqueue_) {
     if (unit.end_of_stream || unit.data.empty()) {
       input_eos_encountered_ = true;
       output_eos_encountered_ = true;
-      callback.Run(MEDIA_CODEC_OUTPUT_END_OF_STREAM, kNoTimestamp(), 0);
+      callback.Run(MEDIA_CODEC_OUTPUT_END_OF_STREAM, kNoTimestamp(),
+                   kNoTimestamp());
       return;
     }
 
     skip_eos_enqueue_ = false;
   }
 
   MediaCodecStatus input_status = MEDIA_CODEC_INPUT_END_OF_STREAM;
   if (!input_eos_encountered_) {
     input_status = QueueInputBuffer(unit);
     if (input_status == MEDIA_CODEC_INPUT_END_OF_STREAM) {
       input_eos_encountered_ = true;
     } else if (input_status != MEDIA_CODEC_OK) {
-      callback.Run(input_status, kNoTimestamp(), 0);
+      callback.Run(input_status, kNoTimestamp(), kNoTimestamp());
       return;
     }
   }
 
   int buffer_index = 0;
   size_t offset = 0;
   size_t size = 0;
   base::TimeDelta presentation_timestamp;
 
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
       kMediaCodecTimeoutInMilliseconds);
 
   MediaCodecStatus status =
       media_codec_bridge_->DequeueOutputBuffer(timeout,
                                                &buffer_index,
                                                &offset,
                                                &size,
                                                &presentation_timestamp,
                                                &output_eos_encountered_,
                                                NULL);
 
   if (status != MEDIA_CODEC_OK) {
     if (status == MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED &&
         !media_codec_bridge_->GetOutputBuffers()) {
       status = MEDIA_CODEC_ERROR;
     }
-    callback.Run(status, kNoTimestamp(), 0);
+    callback.Run(status, kNoTimestamp(), kNoTimestamp());
     return;
   }
 
   // TODO(xhwang/qinmin): This logic is correct but strange. Clean it up.
   if (output_eos_encountered_)
     status = MEDIA_CODEC_OUTPUT_END_OF_STREAM;
   else if (input_status == MEDIA_CODEC_INPUT_END_OF_STREAM)
     status = MEDIA_CODEC_INPUT_END_OF_STREAM;
 
   bool render_output  = presentation_timestamp >= preroll_timestamp_ &&
       (status != MEDIA_CODEC_OUTPUT_END_OF_STREAM || size != 0u);
   base::TimeDelta time_to_render;
   DCHECK(!start_time_ticks.is_null());
   if (render_output && ComputeTimeToRender()) {
     time_to_render = presentation_timestamp - (base::TimeTicks::Now() -
         start_time_ticks + start_presentation_timestamp);
   }
 
   if (time_to_render > base::TimeDelta()) {
     decoder_task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&MediaDecoderJob::ReleaseOutputBuffer,
                    weak_factory_.GetWeakPtr(),
                    buffer_index,
                    size,
                    render_output,
-                   base::Bind(callback, status, presentation_timestamp)),
+                   presentation_timestamp,
+                   base::Bind(callback, status)),
         time_to_render);
     return;
   }
 
   // TODO(qinmin): The codec is lagging behind, need to recalculate the
   // |start_presentation_timestamp_| and |start_time_ticks_| in
   // media_source_player.cc.
   DVLOG(1) << "codec is lagging behind :" << time_to_render.InMicroseconds();
   if (render_output) {
     // The player won't expect a timestamp smaller than the
     // |start_presentation_timestamp|. However, this could happen due to decoder
     // errors.
     presentation_timestamp = std::max(
         presentation_timestamp, start_presentation_timestamp);
   } else {
     presentation_timestamp = kNoTimestamp();
   }
   ReleaseOutputCompletionCallback completion_callback = base::Bind(
-      callback, status, presentation_timestamp);
-  ReleaseOutputBuffer(buffer_index, size, render_output, completion_callback);
+      callback, status);
+  ReleaseOutputBuffer(buffer_index, size, render_output, presentation_timestamp,
+                      completion_callback);
 }
 
 void MediaDecoderJob::OnDecodeCompleted(
-    MediaCodecStatus status, base::TimeDelta presentation_timestamp,
-    size_t audio_output_bytes) {
+    MediaCodecStatus status, base::TimeDelta current_presentation_timestamp,
+    base::TimeDelta max_presentation_timestamp) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   if (destroy_pending_) {
     DVLOG(1) << __FUNCTION__ << " : completing pending deletion";
     delete this;
     return;
   }
 
   DCHECK(!decode_cb_.is_null());
 
   // If output was queued for rendering, then we have completed prerolling.
-  if (presentation_timestamp != kNoTimestamp())
+  if (current_presentation_timestamp != kNoTimestamp())
     prerolling_ = false;
 
   switch (status) {
     case MEDIA_CODEC_OK:
     case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
     case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
     case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
     case MEDIA_CODEC_OUTPUT_END_OF_STREAM:
       if (!input_eos_encountered_)
         access_unit_index_[current_demuxer_data_index_]++;
       break;
 
     case MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
     case MEDIA_CODEC_INPUT_END_OF_STREAM:
     case MEDIA_CODEC_NO_KEY:
     case MEDIA_CODEC_STOPPED:
     case MEDIA_CODEC_ERROR:
       // Do nothing.
       break;
   };
 
   stop_decode_pending_ = false;
-  base::ResetAndReturn(&decode_cb_).Run(status, presentation_timestamp,
-                                        audio_output_bytes);
+  base::ResetAndReturn(&decode_cb_).Run(
+      status, current_presentation_timestamp, max_presentation_timestamp);
 }
 
 const AccessUnit& MediaDecoderJob::CurrentAccessUnit() const {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(HasData());
   int index = NoAccessUnitsRemainingInChunk(true) ?
       inactive_demuxer_data_index() : current_demuxer_data_index_;
   return received_data_[index].access_units[access_unit_index_[index]];
 }
 
@@ skipping 33 matching lines @@
 }
 
 void MediaDecoderJob::InitializeReceivedData() {
   for (size_t i = 0; i < 2; ++i) {
     received_data_[i] = DemuxerData();
     access_unit_index_[i] = 0;
   }
 }
 
 }  // namespace media