MediaCodecPlayer implementation (stage 3 - browser seek and surface change)

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 29 matching lines @@
 //       v                         |   transition      v
 //  [ Prefetching ]                |               [ Error ]
 //       |                         |
 //       | internal transition     |
 //       v                         |            Error recovery:
 //  [ Prefetched ]                 |
 //       |                         |        (any state including Error)
 //       | Configure and Start     |                   |
 //       v                         |                   | ReleaseDecoderResources
 //  [ Running ]                    |                   v
-//       |                         |              [ Stopped ]
-//       | RequestToStop           |
-//       v                         |
-//  [ Stopping ] -------------------
-//
+//       |                         |          [ InEmergencyStop ]
+//       | RequestToStop           |                   |
+//       v                         |                   |(decoder thread stopped)
+//  [ Stopping ] -------------------                   v
+//                                                [ Stopped ]
 //
 //  [ Stopped ] --------------------
 //       ^                         |
 //       |       Flush             |
 //       ---------------------------
 
+// (any state except Error)
+//       |
+//       |  SyncStop
+//       v
+//  [ InEmergencyStop ]
+//       |
+//       |(decoder thread stopped)
+//       v
+//  [ Stopped ]
+
 // Here is the workflow that is expected to be maintained by a caller, which is
 // MediaCodecPlayer currently.
 //
 //  [ Stopped ]
 //       |
 //       | Prefetch
 //       v
 //  [ Prefetching ]
 //       |
 //       | (Enough data received)
@@ skipping 28 matching lines @@
 // (*) Demuxer configs is a precondition to Configure(), but MediaCodecPlayer
 //     has stricter requirements and they are set before Prefetch().
 //
 // (**) VideoSurface is a precondition to video decoder Configure(), can be set
 //      any time before Configure().
 
 class MediaCodecDecoder {
  public:
   // The result of MediaCodec configuration, used by MediaCodecPlayer.
   enum ConfigStatus {
-    CONFIG_FAILURE = 0,
-    CONFIG_OK,
-    CONFIG_KEY_FRAME_REQUIRED,
+    kConfigFailure = 0,
+    kConfigOk,
+    kConfigKeyFrameRequired,
   };
 
   // The decoder reports current playback time to the MediaCodecPlayer.
   // For audio, the parameters designate the beginning and end of a time
   // interval. The beginning is the estimated time that is playing right now.
   // The end is the playback time of the last buffered data. During normal
   // playback the subsequent intervals overlap.
   // For video both values are PTS of the corresponding frame, i.e. the interval
   // has zero width.
   typedef base::Callback<void(base::TimeDelta, base::TimeDelta)>
@@ skipping 101 matching lines @@
   // a delayed task to do it at a later time,
   virtual void Render(int buffer_index,
                       size_t size,
                       bool render_output,
                       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
-  // because their rendering is delayed (video).
-  virtual void ReleaseDelayedBuffers() {}
+  // 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) {}
 
 #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.
 
   // Notifies the decoder if the frame is the last one.
   void CheckLastFrame(bool eos_encountered, bool has_delayed_tasks);
 
   // 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,
     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.
   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 ProcessNextFrame.
   // Pulls all currently available output frames and renders them.
-  // Returns false if there was MediaCodec error.
-  bool DepleteOutputBufferQueue(bool* eos_encountered);
+  // 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_;
 
@@ skipping 35 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_