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

media/base/android/media_decoder_job.h

 // 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.
 
 #ifndef MEDIA_BASE_ANDROID_MEDIA_DECODER_JOB_H_
 #define MEDIA_BASE_ANDROID_MEDIA_DECODER_JOB_H_
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
@@ skipping 11 matching lines @@
 // Data is stored in 2 chunks. When new data arrives, it is always stored in
 // an inactive chunk. And when the current active chunk becomes empty, a new
 // data request will be sent to the renderer.
 class MediaDecoderJob {
  public:
   struct Deleter {
     inline void operator()(MediaDecoderJob* ptr) const { ptr->Release(); }
   };
 
   // Callback when a decoder job finishes its work. Args: whether decode
-  // finished successfully, presentation time, audio output bytes.
-  // If the presentation time is equal to kNoTimestamp(), the decoder job
-  // skipped rendering of the decoded output and the callback target should
+  // finished successfully, current presentation time, max presentation time.
+  // If the current presentation time is equal to kNoTimestamp(), the decoder
+  // job skipped rendering of the decoded output and the callback target should
   // update its clock to avoid introducing extra delays to the next frame.
   typedef base::Callback<void(MediaCodecStatus, base::TimeDelta,
-                              size_t)> DecoderCallback;
+                              base::TimeDelta)> DecoderCallback;
   // Callback when a decoder job finishes releasing the output buffer.
-  // Args: audio output bytes, must be 0 for video.
-  typedef base::Callback<void(size_t)> ReleaseOutputCompletionCallback;
+  // Args: current presentation time, max presentation time.
+  typedef base::Callback<void(base::TimeDelta, base::TimeDelta)>
+      ReleaseOutputCompletionCallback;
 
   virtual ~MediaDecoderJob();
 
   // Called by MediaSourcePlayer when more data for this object has arrived.
   void OnDataReceived(const DemuxerData& data);
 
   // Prefetch so we know the decoder job has data when we call Decode().
   // |prefetch_cb| - Run when prefetching has completed.
   void Prefetch(const base::Closure& prefetch_cb);
 
@@ skipping 37 matching lines @@
       const scoped_refptr<base::SingleThreadTaskRunner>& decoder_task_runner,
       MediaCodecBridge* media_codec_bridge,
       const base::Closure& request_data_cb);
 
   // Release the output buffer at index |output_buffer_index| and render it if
   // |render_output| is true. Upon completion, |callback| will be called.
   virtual void ReleaseOutputBuffer(
       int output_buffer_index,
       size_t size,
       bool render_output,
+      base::TimeDelta current_presentation_timestamp,
       const ReleaseOutputCompletionCallback& callback) = 0;
 
   // Returns true if the "time to render" needs to be computed for frames in
   // this decoder job.
   virtual bool ComputeTimeToRender() const = 0;
 
  private:
   friend class MediaSourcePlayerTest;
 
   // Causes this instance to be deleted on the thread it is bound to.
@@ skipping 22 matching lines @@
   void DecodeInternal(const AccessUnit& unit,
                       base::TimeTicks start_time_ticks,
                       base::TimeDelta start_presentation_timestamp,
                       bool needs_flush,
                       const DecoderCallback& callback);
 
   // Called on the UI thread to indicate that one decode cycle has completed.
   // Completes any pending job destruction or any pending decode stop. If
   // destruction was not pending, passes its arguments to |decode_cb_|.
   void OnDecodeCompleted(MediaCodecStatus status,
-                         base::TimeDelta presentation_timestamp,
-                         size_t audio_output_bytes);
+                         base::TimeDelta current_presentation_timestamp,
+                         base::TimeDelta max_presentation_timestamp);
 
   // Helper function to get the current access unit that is being decoded.
   const AccessUnit& CurrentAccessUnit() const;
 
   // Check whether a chunk has no remaining access units to decode. If
   // |is_active_chunk| is true, this function returns whether decoder has
   // consumed all data in |received_data_[current_demuxer_data_index_]|.
   // Otherwise, it returns whether decoder has consumed all data in the inactive
   // chunk.
   bool NoAccessUnitsRemainingInChunk(bool is_active_chunk) const;
@@ skipping 95 matching lines @@
   // the decoder thread.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaDecoderJob> weak_factory_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MediaDecoderJob);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_DECODER_JOB_H_