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 14 matching lines @@
 // This class accepts the incoming data into AccessUnitQueue and works with
 // MediaCodecBridge for decoding and rendering the frames. The MediaCodecPlayer
 // has two decoder objects: audio and video.
 //
 // The decoder works on two threads. The data from demuxer comes on Media
 // thread. The commands from MediaCodecPlayer, such as Prefetch, Start,
 // RequestToStop also come on the Media thread. The operations with MediaCodec
 // buffers and rendering happen on a separate thread called Decoder thread.
 // This class creates, starts and stops it as necessary.
 //
 // Decoder's internal state machine goes through the following states:

[wolenetz, 2015/07/29 22:37:03]

nit: InEmergencyStop is missing from these diagrams

[Tima Vaisburd, 2015/07/30 20:28:35]

Done.

 //
 //  [ Stopped ] <-------------------          (any state except Error)
 //       |                         |                   |
 //       | Prefetch                |--- internal ------|
 //       v                         |   transition      v
 //  [ Prefetching ]                |               [ Error ]
 //       |                         |
 //       | internal transition     |
 //       v                         |            Error recovery:
 //  [ Prefetched ]                 |
@@ skipping 53 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,

[wolenetz, 2015/07/29 22:37:02]

Hmm. Here and elsewhere in the new mediacodecplayer/decoder/etc, please use
kConstant, not MACRO, naming style for enumerated values (Chromium style guide:
"New code should prefer constant-style naming if possible").

[Tima Vaisburd, 2015/07/30 20:28:35]

Done.

     CONFIG_OK,
     CONFIG_KEY_FRAME_REQUIRED,
   };
 
   // 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
@@ skipping 103 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_