MediaCodecPlayer implementation (stage 5 - reconfiguration)

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 131 matching lines @@
   //     called on this thread, and callbacks are delivered on this thread.
   //     The MediaCodecPlayer uses a dedicated (Media) thread for this.
   //   external_request_data_cb:
   //     Called periodically as the amount of internally stored data decreases.
   //     The receiver should call OnDemuxerDataAvailable() with more data.
   //   starvation_cb:
   //     Called when starvation is detected. The decoder state does not change.
   //     The player is supposed to stop and then prefetch the decoder.
   //   stop_done_cb:
   //     Called when async stop request is completed.
+  //   decoder_drained_cb:
+  //     Called when decoder is drained for reconfiguration.
   //   error_cb:
   //     Called when a MediaCodec error occurred. If this happens, a player has
   //     to either call ReleaseDecoderResources() or destroy the decoder object.
   //   decoder_thread_name:
   //     The thread name to be passed to decoder thread constructor.
   MediaCodecDecoder(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const base::Closure& external_request_data_cb,
       const base::Closure& starvation_cb,
+      const base::Closure& decoder_drained_cb,
       const base::Closure& stop_done_cb,
       const base::Closure& error_cb,
       const char* decoder_thread_name);
   virtual ~MediaCodecDecoder();
 
   virtual const char* class_name() const;
 
   // 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)
@@ skipping 12 matching lines @@
 
   // 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;
 
+  // Requests an A/V sync mechanism that is similar to preroll, but stops at the
+  // first available output frame rather than passing certain PTS.
+  void SetDecodingUntilOutputIsPresent();
+
   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 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);
+  void OnLastFrameRendered(bool eos_encountered);
 
   // 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.
+  // For testing only.
+
+  // Returns true if the decoder is in kPrerolling state.
   bool IsPrerollingForTests() const;
 
+  // Drains decoder and reconfigures for each |kConfigChanged|.
+  void SetAlwaysReconfigureForTests();
+
+  // Sets the notification to be called when MediaCodec is created.
+  void SetCodecCreatedCallbackForTests(base::Closure cb);
+
  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;
+  virtual bool IsCodecReconfigureNeeded(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 AssociateCurrentTimeWithPTS(base::TimeDelta current_time) {}
 
   // Invalidate delay calculation. We use delays for video decoder only.
@@ skipping 47 matching lines @@
   // 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_;
 
+  // Flag forces to drain decoder in the process of dynamic reconfiguration.
+  bool drain_decoder_;
+
+  // For tests only. Forces to always reconfigure for |kConfigChanged| unit.
+  bool always_reconfigure_for_tests_;
+
+  // For tests only. Callback to be callned when MediaCodec is created.
+  base::Closure codec_created_for_tests_cb_;
+
  private:
   enum DecoderState {
     kStopped = 0,
     kPrefetching,
     kPrefetched,
     kPrerolling,
     kPrerolled,
     kRunning,
     kStopping,
     kInEmergencyStop,
     kError,
   };
 
+  enum PrerollMode {
+    kNoPreroll = 0,
+    kPrerollTillOutputIsPresent,
+    kPrerollTillPTS,
+  };
+
   // Helper method that processes an error from MediaCodec.
   void OnCodecError();
 
   // Requests data. Ensures there is no more than one request at a time.
   void RequestData();
 
   // Prefetching callback that is posted to Media thread
   // in the kPrefetching state.
   void PrefetchNextChunk();
 
   // The callback to do actual playback. Posted to Decoder thread
   // in the kRunning state.
   void ProcessNextFrame();
 
   // Helper method for ProcessNextFrame.
   // Pushes one input buffer to the MediaCodec if the codec can accept it.
   // Returns false if there was MediaCodec error.
   bool EnqueueInputBuffer();
 
+  // Helper method for EnqueueInputBuffer.
+  // Gets the next data frame from the queue, requesting more data and saving
+  // configuration changes on the way. Sets |drain_decoder| to true of any of
+  // the configuration changes requires draining the decoder. Returns the Info
+  // pointing to the current data unit ot empty Info if it got past the end of
+  // the queue.
+  AccessUnitQueue::Info AdvanceAccessUnitQueue(bool* drain_decoder);
+
   // Helper method for ProcessNextFrame.
   // Pulls all currently available output frames and renders them.
   // Returns true if we need to continue decoding process, i.e post next
   // ProcessNextFrame method, and false if we need to stop decoding.
   bool DepleteOutputBufferQueue();
 
   DecoderState GetState() const;
   void SetState(DecoderState state);
   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 decoder_drained_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_;
+  // The preroll mode. If not |kNoPreroll|, the playback should start with
+  // preroll.
+  PrerollMode preroll_mode_;
 
   // 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_;
 
@@ skipping 10 matching lines @@
 
   // 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_