Reducing the IPC latency for MSE video decoding

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 32 matching lines @@
                     MediaPlayerManager* manager,
                     const RequestMediaResourcesCB& request_media_resources_cb,
                     const ReleaseMediaResourcesCB& release_media_resources_cb,
                     scoped_ptr<DemuxerAndroid> demuxer);
   virtual ~MediaSourcePlayer();
 
   // MediaPlayerAndroid implementation.
   virtual void SetVideoSurface(gfx::ScopedJavaSurface surface) OVERRIDE;
   virtual void Start() OVERRIDE;
   virtual void Pause(bool is_media_related_action ALLOW_UNUSED) OVERRIDE;
-  virtual void SeekTo(const base::TimeDelta& timestamp) OVERRIDE;
+  virtual void SeekTo(base::TimeDelta timestamp) OVERRIDE;
   virtual void Release() OVERRIDE;
   virtual void SetVolume(double volume) OVERRIDE;
   virtual int GetVideoWidth() OVERRIDE;
   virtual int GetVideoHeight() OVERRIDE;
   virtual base::TimeDelta GetCurrentTime() OVERRIDE;
   virtual base::TimeDelta GetDuration() OVERRIDE;
   virtual bool IsPlaying() OVERRIDE;
   virtual bool CanPause() OVERRIDE;
   virtual bool CanSeekForward() OVERRIDE;
   virtual bool CanSeekBackward() OVERRIDE;
   virtual bool IsPlayerReady() OVERRIDE;
   virtual void SetDrmBridge(MediaDrmBridge* drm_bridge) OVERRIDE;
   virtual void OnKeyAdded() OVERRIDE;
   virtual bool IsSurfaceInUse() const OVERRIDE;
 
   // DemuxerAndroidClient implementation.
   virtual void OnDemuxerConfigsAvailable(const DemuxerConfigs& params) OVERRIDE;
   virtual void OnDemuxerDataAvailable(const DemuxerData& params) OVERRIDE;
   virtual void OnDemuxerSeekDone(
-      const base::TimeDelta& actual_browser_seek_time) OVERRIDE;
+      base::TimeDelta actual_browser_seek_time) OVERRIDE;
   virtual void OnDemuxerDurationChanged(base::TimeDelta duration) OVERRIDE;
 
  private:
   friend class MediaSourcePlayerTest;
 
   // Update the current timestamp.
-  void UpdateTimestamps(const base::TimeDelta& presentation_timestamp,
+  void UpdateTimestamps(base::TimeDelta presentation_timestamp,
                         size_t audio_output_bytes);
 
   // 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,
-        const base::TimeDelta& presentation_timestamp,
+        base::TimeDelta presentation_timestamp,
         size_t audio_output_bytes);
 
   // 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();
 
   // Helper method to clear any pending |SURFACE_CHANGE_EVENT_PENDING|
   // and reset |video_decoder_job_| to null.
   void ResetVideoDecoderJob();
+  void ResetAudioDecoderJob();
 
   // Helper methods to configure the decoder jobs.
   void ConfigureVideoDecoderJob();
   void ConfigureAudioDecoderJob();
 
   // Flush the decoders and clean up all the data needs to be decoded.
   void ClearDecodingData();
 
   // Called to decode more data.
   void DecodeMoreAudio();
@@ skipping 11 matching lines @@
   // 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(const base::TimeDelta& presentation_timestamp);
+  void StartStarvationCallback(base::TimeDelta 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(const base::TimeDelta& seek_time);
+  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
   // seek time.
   // TODO(wolenetz): Instead of doing hack browser seek, replay cached data
   // since last keyframe. See http://crbug.com/304234.
   void BrowserSeekToCurrentTime();
 
   // Helper function to set the volume.
@@ skipping 119 matching lines @@
   // 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_