text: // Copyright 2013 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_GPU_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_
  #define MEDIA_GPU_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_
  
  #include <stddef.h>
  #include <stdint.h>
  
  #include <list>
  #include <memory>
  #include <queue>
  #include <tuple>
  #include <vector>
  
  #include "base/macros.h"
  #include "base/memory/weak_ptr.h"
  #include "base/threading/thread_checker.h"
  #include "base/timer/timer.h"
  #include "media/base/android/sdk_media_codec_bridge.h"
  #include "media/gpu/media_gpu_export.h"
  #include "media/video/video_encode_accelerator.h"
  
  namespace media {
  
  class BitstreamBuffer;
  
  // Android-specific implementation of VideoEncodeAccelerator, enabling
  // hardware-acceleration of video encoding, based on Android's MediaCodec class
  // (http://developer.android.com/reference/android/media/MediaCodec.html).  This
  // class expects to live and be called on a single thread (the GPU process'
  // ChildThread).
  class MEDIA_GPU_EXPORT AndroidVideoEncodeAccelerator
      : public VideoEncodeAccelerator {
   public:
    AndroidVideoEncodeAccelerator();
    ~AndroidVideoEncodeAccelerator() override;
  
    // VideoEncodeAccelerator implementation.
    VideoEncodeAccelerator::SupportedProfiles GetSupportedProfiles() override;
    bool Initialize(VideoPixelFormat format,
                    const gfx::Size& input_visible_size,
                    VideoCodecProfile output_profile,
                    uint32_t initial_bitrate,
                    Client* client) override;
    void Encode(const scoped_refptr<VideoFrame>& frame,
                bool force_keyframe) override;
    void UseOutputBitstreamBuffer(const BitstreamBuffer& buffer) override;
    void RequestEncodingParametersChange(uint32_t bitrate,
                                         uint32_t framerate) override;
    void Destroy() override;
  
   private:
    enum {
      // Arbitrary choice.
      INITIAL_FRAMERATE = 30,
      // Default I-Frame interval in seconds.
      IFRAME_INTERVAL_H264 = 20,
      IFRAME_INTERVAL_VPX = 100,
      IFRAME_INTERVAL = INT32_MAX,
    };
  
    // Impedance-mismatch fixers: MediaCodec is a poll-based API but VEA is a
    // push-based API; these methods turn the crank to make the two work together.
    void DoIOTask();
    void QueueInput();
    void DequeueOutput();
  
    // Start & stop |io_timer_| if the time seems right.
    void MaybeStartIOTimer();
    void MaybeStopIOTimer();
  
    // Used to DCHECK that we are called on the correct thread.
    base::ThreadChecker thread_checker_;
  
    // VideoDecodeAccelerator::Client callbacks go here.  Invalidated once any
    // error triggers.
    std::unique_ptr<base::WeakPtrFactory<Client>> client_ptr_factory_;
  
    std::unique_ptr<VideoCodecBridge> media_codec_;
  
    // Bitstream buffers waiting to be populated & returned to the client.
    std::vector<BitstreamBuffer> available_bitstream_buffers_;
  
    // Frames waiting to be passed to the codec, queued until an input buffer is
    // available.  Each element is a tuple of <Frame, key_frame, enqueue_time>.
    typedef std::queue<std::tuple<scoped_refptr<VideoFrame>, bool, base::Time>>
        PendingFrames;
    PendingFrames pending_frames_;
  
    // Repeating timer responsible for draining pending IO to the codec.
    base::RepeatingTimer io_timer_;
  
    // The difference between number of buffers queued & dequeued at the codec.
    int32_t num_buffers_at_codec_;
  
    // A monotonically-growing value.
    base::TimeDelta input_timestamp_;
  
    // Resolution of input stream. Set once in initialization and not allowed to
    // change after.
    gfx::Size frame_size_;
  
    uint32_t last_set_bitrate_;  // In bps.
  
    // True if there is encoder error.
    bool error_occurred_;
  
    DISALLOW_COPY_AND_ASSIGN(AndroidVideoEncodeAccelerator);
  };
  
  }  // namespace media
  
  #endif  // MEDIA_GPU_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_
  