Implementation of MediaCodecPlayer stage 1

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"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/thread.h"
+#include "base/time/time.h"
+#include "media/base/android/access_unit_queue.h"
+#include "media/base/android/demuxer_stream_player_params.h"
+
+namespace media {
+
+class MediaCodecBridge;
+
+// The decoder for MediaCodecPlayer.
+// 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.
+// However, the operations with MediaCodec buffers and rendering
+// happen on a separate thread called Decoder thread.
+// This class creates, starts and stops it as necessary.
+class MediaCodecDecoder {
+ public:
+  // The result of MediaCodec configuration, used by MediaCodecPlayer.
+  enum ConfigStatus {
+    CONFIG_FAILURE = 0,
+    CONFIG_OK,
+    CONFIG_KEY_FRAME_REQUIRED,
+  };
+
+  // The decoder reports current playback time to the MediaCodecPlayer.
+  typedef base::Callback<void(base::TimeDelta, base::TimeDelta)>
+      SetTimeCallback;
+
+  MediaCodecDecoder(
+      const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+      const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner,
+      const base::Closure& request_data_cb,
+      const base::Closure& starvation_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 { return "Decoder"; }
+
+  // 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;
+
+  // Stop decoder thread, release the MediaCodecBridge and other resources.
+  virtual void ReleaseDecoderResources();
+
+  // Flush the MediaCodec and reset the AccessUnitQueue.
+  // Decoder thread should not be running.
+  virtual void Flush();
+
+  // Release MediaCodecBridge.
+  void ReleaseMediaCodec();
+
+  // Return corresponding conditions.
+  bool IsPrefetchingOrPlaying() const;
+  bool IsStopped() const;
+  bool IsCompleted() const;
+
+  // Store configuration for the use of upcoming Configure()
+  void SetDemuxerConfigs(const DemuxerConfigs& configs);
+
+  base::android::ScopedJavaLocalRef<jobject> GetMediaCrypto();
+
+  // Start prefetching: accumulate enough data in AccessUnitQueue.
+  // Decoder thread is not running.
+  void Prefetch(const base::Closure& prefetch_done_cb);
+
+  // Configure MediaCodec.
+  ConfigStatus Configure();
+
+  // Start the decoder thread and resume the playback.
+  bool Start(base::TimeDelta current_time);
+
+  // Stop the playback process synchronously.
+  // This method stops the decoder thread synchronously,
+  // and then releases all MediaCodec buffers.
+  void SyncStop();
+
+  // Request to stop the playback and return.
+  // Decoder will stop asynchronously after all the dequeued
+  // buffers are rendered.
+  void RequestToStop();
+
+  // Puts the incoming data into AccessUnitQueue.
+  void OnDemuxerDataAvailable(const DemuxerData& data);
+
+  // Notification posted when asynchronous stop is done
+  // or the playback is completed.
+  void OnLastFrameRendered(bool completed);
+
+ protected:
+  // Returns true if the new DemuxerConfids 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;
+
+  // Associate PTS with device time so we can calculate delays.
+  // We use delays for video decoder only.
+  virtual void SynchronizePTSWithTime(base::TimeDelta current_time) {}
+
+  // Render the decoded frame and release output buffer, or post
+  // 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;
+
+  // For video we might have delayed tasks.
+  virtual int NumDelayedRenderTasks() const { return 0; }
+
+  // Release output buffers that are dequeued and not released yet
+  // because their rendering is delayed (video).
+  virtual void ReleaseDelayedBuffers() {}
+
+  // Helper methods.
+
+  // Notify 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_;
+
+  // Object for posting tasks on UI thread.
+  scoped_refptr<base::SingleThreadTaskRunner> ui_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_;
+
+  // Configuration received from demuxer
+  DemuxerConfigs configs_;
+  mutable base::Lock configs_lock_;
+
+  // The queue of access units.
+  AccessUnitQueue au_queue_;
+
+ private:
+  enum DecoderState {
+    STOPPED = 0,
+    PREFETCHING,
+    RUNNING,
+    STOPPING
+  };
+
+  // Prefetching callback that is posted to Media thread
+  // in the PREFETCHING state.
+  void PrefetchNextChunk();
+
+  // The callback to do actual playback. Posted to Decoder thread
+  // in the RUNNING mode
+  void ProcessNextFrame();
+
+  // Helper method for ProcessNextFrame.
+  // Pushes one input buffer to the MediaCodec if the codec ca 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);
+
+  DecoderState GetState() const;
+  void SetState(DecoderState state);
+
+  // Private Data.
+
+  // Callback used to request more data.
+  base::Closure request_data_cb_;
+
+  // These notifications are called on corresponding conditions.
+  base::Closure prefetch_done_cb_;
+  base::Closure starvation_cb_;
+  base::Closure stop_done_cb_;
+  base::Closure error_cb_;
+
+  DecoderState state_;
+  mutable base::Lock state_lock_;
+
+  // Flag is set when the EOS is enqueued into MediaCodec.
+  bool eos_enqueued_;
+
+  // Flag is set when the EOS is received in MediaCodec output.
+  bool completed_;
+
+  // Flag to ensure we post last frame notification once.
+  bool last_frame_posted_;
+
+  base::WeakPtr<MediaCodecDecoder> weak_this_;
+  // 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_