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

media/base/android/media_source_player.h

 // Copyright (c) 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_SOURCE_PLAYER_H_
 #define MEDIA_BASE_ANDROID_MEDIA_SOURCE_PLAYER_H_
 
 #include <jni.h>
 #include <map>
 #include <string>
@@ skipping 11 matching lines @@
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/media_decoder_job.h"
 #include "media/base/android/media_drm_bridge.h"
 #include "media/base/android/media_player_android.h"
 #include "media/base/clock.h"
 #include "media/base/media_export.h"
 
 namespace media {
 
 class AudioDecoderJob;
-class AudioTimestampHelper;
 class VideoDecoderJob;
 
 // This class handles media source extensions on Android. It uses Android
 // MediaCodec to decode audio and video streams in two separate threads.
 class MEDIA_EXPORT MediaSourcePlayer : public MediaPlayerAndroid,
                                        public DemuxerAndroidClient {
  public:
   // Constructs a player with the given ID and demuxer. |manager| must outlive
   // the lifetime of this object.
   MediaSourcePlayer(int player_id,
@@ skipping 27 matching lines @@
   virtual void OnDemuxerConfigsAvailable(const DemuxerConfigs& params) OVERRIDE;
   virtual void OnDemuxerDataAvailable(const DemuxerData& params) OVERRIDE;
   virtual void OnDemuxerSeekDone(
       base::TimeDelta actual_browser_seek_time) OVERRIDE;
   virtual void OnDemuxerDurationChanged(base::TimeDelta duration) OVERRIDE;
 
  private:
   friend class MediaSourcePlayerTest;
 
   // Update the current timestamp.
-  void UpdateTimestamps(base::TimeDelta presentation_timestamp,
-                        size_t audio_output_bytes);
+  void UpdateTimestamps(base::TimeDelta current_presentation_timestamp,
+                        base::TimeDelta max_presentation_timestamp);
 
   // Helper function for starting media playback.
   void StartInternal();
 
   // Playback is completed for one channel.
   void PlaybackCompleted(bool is_audio);
 
   // Called when the decoder finishes its task.
   void MediaDecoderCallback(
         bool is_audio, MediaCodecStatus status,
-        base::TimeDelta presentation_timestamp,
-        size_t audio_output_bytes);
+        base::TimeDelta current_presentation_timestamp,
+        base::TimeDelta max_presentation_timestamp);
 
   // Gets MediaCrypto object from |drm_bridge_|.
   base::android::ScopedJavaLocalRef<jobject> GetMediaCrypto();
 
   // Callback to notify that MediaCrypto is ready in |drm_bridge_|.
   void OnMediaCryptoReady();
 
   // Handle pending events if all the decoder jobs are not currently decoding.
   void ProcessPendingEvents();
 
@@ skipping 22 matching lines @@
   bool AudioFinished();
   bool VideoFinished();
 
   // Determine seekability based on duration.
   bool Seekable();
 
   // Called when the |decoder_starvation_callback_| times out.
   void OnDecoderStarved();
 
   // Starts the |decoder_starvation_callback_| task with the timeout value.
-  // |presentation_timestamp| - The presentation timestamp used for starvation
-  // timeout computations. It represents the timestamp of the last piece of
-  // decoded data.
-  void StartStarvationCallback(base::TimeDelta presentation_timestamp);
+  // |current_presentation_timestamp| - The presentation timestamp used for
+  // starvation timeout computations. It represents the current timestamp of
+  // rendered data.
+  // |max_presentation_timestamp| - The presentation timestamp if all the
+  // decoded data are rendered.
+  void StartStarvationCallback(
+      base::TimeDelta current_presentation_timestamp,
+      base::TimeDelta max_presentation_timestamp);
 
   // Schedules a seek event in |pending_events_| and calls StopDecode() on all
   // the MediaDecoderJobs. Sets clock to |seek_time|, and resets
   // |pending_seek_|. There must not already be a seek event in
   // |pending_events_|.
   void ScheduleSeekEventAndStopDecoding(base::TimeDelta seek_time);
 
   // Schedules a browser seek event. We must not currently be processing any
   // seek. Note that there is possibility that browser seek of renderer demuxer
   // may unexpectedly stall due to lack of buffered data at or after the browser
@@ skipping 109 matching lines @@
 
   // Track the most recent preroll target. Decoder re-creation needs this to
   // resume any in-progress preroll.
   base::TimeDelta preroll_timestamp_;
 
   // A cancelable task that is posted when the audio decoder starts requesting
   // new data. This callback runs if no data arrives before the timeout period
   // elapses.
   base::CancelableClosure decoder_starvation_callback_;
 
-  // Object to calculate the current audio timestamp for A/V sync.
-  scoped_ptr<AudioTimestampHelper> audio_timestamp_helper_;
-
   MediaDrmBridge* drm_bridge_;
 
   // No decryption key available to decrypt the encrypted buffer. In this case,
   // the player should pause. When a new key is added (OnKeyAdded()), we should
   // try to start playback again.
   bool is_waiting_for_key_;
 
   // Test-only callback for hooking the completion of the next decode cycle.
   base::Closure decode_callback_for_testing_;
 
   // Whether |surface_| is currently used by the player.
   bool is_surface_in_use_;
 
   // Whether there are pending data requests by the decoder.
   bool has_pending_audio_data_request_;
   bool has_pending_video_data_request_;
 
   // Weak pointer passed to media decoder jobs for callbacks.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaSourcePlayer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_SOURCE_PLAYER_H_