MediaCodecPlayer implementation (stage 4 - preroll)

media/base/android/media_codec_decoder.h

 // 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.
 
 #ifndef MEDIA_BASE_ANDROID_MEDIA_CODEC_DECODER_H_
 #define MEDIA_BASE_ANDROID_MEDIA_CODEC_DECODER_H_
 
 #include "base/android/scoped_java_ref.h"
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 153 matching lines @@
   // MediaCodecDecoder exists through the whole lifetime of the player
   // to support dynamic addition and removal of the streams.
   // This method returns true if the current stream (audio or video)
   // is currently active.
   virtual bool HasStream() const = 0;
 
   // Stores configuration for the use of upcoming Configure()
   virtual void SetDemuxerConfigs(const DemuxerConfigs& configs) = 0;
 
   // Stops decoder thread, releases the MediaCodecBridge and other resources.
-  virtual void ReleaseDecoderResources();
+  virtual void ReleaseDecoderResources() = 0;
 
   // Flushes the MediaCodec, after that resets the AccessUnitQueue and blocks
   // the input. Decoder thread should not be running.
   virtual void Flush();
 
-  // Releases MediaCodecBridge.
-  void ReleaseMediaCodec();
+  // Releases MediaCodecBridge and any related buffers or references.
+  virtual void ReleaseMediaCodec();
 
   // Returns corresponding conditions.
   bool IsPrefetchingOrPlaying() const;
   bool IsStopped() const;
   bool IsCompleted() const;
+  bool NotCompletedAndNeedsPreroll() const;
 
   base::android::ScopedJavaLocalRef<jobject> GetMediaCrypto();
 
   // Starts prefetching: accumulates enough data in AccessUnitQueue.
   // Decoder thread is not running.
   void Prefetch(const base::Closure& prefetch_done_cb);
 
   // Configures MediaCodec.
   ConfigStatus Configure();
 
-  // Starts the decoder thread and resumes the playback.
-  bool Start(base::TimeDelta current_time);
+  // Starts the decoder for prerolling. This method starts the decoder thread.
+  bool Preroll(base::TimeDelta preroll_timestamp,
+               const base::Closure& preroll_done_cb);
+
+  // Starts the decoder after preroll is not needed, starting decoder thread
+  // if it has not started yet.
+  bool Start(base::TimeDelta start_timestamp);
 
   // Stops the playback process synchronously. This method stops the decoder
   // thread synchronously, and then releases all MediaCodec buffers.
   void SyncStop();
 
   // Requests to stop the playback and returns.
   // Decoder will stop asynchronously after all the dequeued output buffers
   // are rendered.
   void RequestToStop();
 
   // Notification posted when asynchronous stop is done or playback completed.
   void OnLastFrameRendered(bool completed);
 
+  // Notification posted when last prerolled frame has been returned to codec.
+  void OnPrerollDone();
+
   // Puts the incoming data into AccessUnitQueue.
   void OnDemuxerDataAvailable(const DemuxerData& data);
 
+  // For testing only. Returns true if the decoder is in kPrerolling state.
+  bool IsPrerollingForTests() const;
+
  protected:
+  enum RenderMode {
+    kRenderSkip = 0,
+    kRenderAfterPreroll,
+    kRenderNow,
+  };
+
   // Returns true if the new DemuxerConfigs requires MediaCodec
   // reconfiguration.
   virtual bool IsCodecReconfigureNeeded(const DemuxerConfigs& curr,
                                         const DemuxerConfigs& next) const = 0;
 
   // Does the part of MediaCodecBridge configuration that is specific
   // to audio or video.
   virtual ConfigStatus ConfigureInternal() = 0;
 
   // Associates PTS with device time so we can calculate delays.
   // We use delays for video decoder only.
-  virtual void SynchronizePTSWithTime(base::TimeDelta current_time) {}
+  virtual void AssociateCurrentTimeWithPTS(base::TimeDelta current_time) {}
+
+  // Invalidate delay calculation. We use delays for video decoder only.
+  virtual void DissociatePTSFromTime() {}
 
   // Processes the change of the output format, varies by stream.
   virtual void OnOutputFormatChanged() = 0;
 
   // Renders the decoded frame and releases output buffer, or posts
   // a delayed task to do it at a later time,
   virtual void Render(int buffer_index,
                       size_t offset,
                       size_t size,
-                      bool render_output,
+                      RenderMode render_mode,
                       base::TimeDelta pts,
                       bool eos_encountered) = 0;
 
   // Returns the number of delayed task (we might have them for video).
   virtual int NumDelayedRenderTasks() const;
 
-  // Releases output buffers that are dequeued and not released yet (video)
-  // if the |release| parameter is set and then remove the references to them.
-  virtual void ClearDelayedBuffers(bool release) {}
+  // Releases output buffers that are dequeued and not released yet (video).
+  virtual void ReleaseDelayedBuffers() {}
 
 #ifndef NDEBUG
   // For video, checks that access unit is the key frame or stand-alone EOS.
   virtual void VerifyUnitIsKeyFrame(const AccessUnit* unit) const {}
 #endif
 
   // Helper methods.
 
+  // Synchroniously stop decoder thread.
+  void DoEmergencyStop();
+
+  // Returns true if we are in the process of sync stop.
+  bool InEmergencyStop() const { return GetState() == kInEmergencyStop; }
+
   // Notifies the decoder if the frame is the last one.
   void CheckLastFrame(bool eos_encountered, bool has_delayed_tasks);
 
-  // Returns true is we are in the process of sync stop.
-  bool InEmergencyStop() const { return GetState() == kInEmergencyStop; }
+  const char* AsString(RenderMode render_mode);
 
   // Protected data.
 
   // Object for posting tasks on Media thread.
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
   // Controls Android MediaCodec
   scoped_ptr<MediaCodecBridge> media_codec_bridge_;
 
   // We call MediaCodecBridge on this thread for both
   // input and output buffers.
   base::Thread decoder_thread_;
 
   // The queue of access units.
   AccessUnitQueue au_queue_;
 
   // Flag forces reconfiguration even if |media_codec_bridge_| exists. Currently
   // is set by video decoder when the video surface changes.
   bool needs_reconfigure_;
 
  private:
   enum DecoderState {
     kStopped = 0,
     kPrefetching,
     kPrefetched,
+    kPrerolling,
+    kPrerolled,
     kRunning,
     kStopping,
     kInEmergencyStop,
     kError,
   };
 
   // Helper method that processes an error from MediaCodec.
   void OnCodecError();
 
   // Requests data. Ensures there is no more than one request at a time.
@@ skipping 23 matching lines @@
   const char* AsString(DecoderState state);
 
   // Private Data.
 
   // External data request callback that is passed to decoder.
   base::Closure external_request_data_cb_;
 
   // These notifications are called on corresponding conditions.
   base::Closure prefetch_done_cb_;
   base::Closure starvation_cb_;
+  base::Closure preroll_done_cb_;
   base::Closure stop_done_cb_;
   base::Closure error_cb_;
 
   // Data request callback that is posted by decoder internally.
   base::Closure request_data_cb_;
 
   // Callback used to post OnCodecError method.
   base::Closure internal_error_cb_;
 
+  // Callback for posting OnPrerollDone method.
+  base::Closure internal_preroll_done_cb_;
+
   // Internal state.
   DecoderState state_;
   mutable base::Lock state_lock_;
 
+  // Preroll timestamp is set if we need preroll and cleared after we done it.
+  base::TimeDelta preroll_timestamp_;
+
+  // Indicates that playback should start with preroll.
+  bool needs_preroll_;
+
   // Flag is set when the EOS is enqueued into MediaCodec. Reset by Flush.
   bool eos_enqueued_;
 
   // Flag is set when the EOS is received in MediaCodec output. Reset by Flush.
   bool completed_;
 
   // Flag to ensure we post last frame notification once.
   bool last_frame_posted_;
 
   // Indicates whether the data request is in progress.
   bool is_data_request_in_progress_;
 
   // Indicates whether the incoming data should be ignored.
   bool is_incoming_data_invalid_;
 
 #ifndef NDEBUG
   // When set, we check that the following video frame is the key frame.
   bool verify_next_frame_is_key_;
 #endif
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaCodecDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecDecoder);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_CODEC_DECODER_H_