src/content/common/gpu/media/android_video_encode_accelerator.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_
   6 #define CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_
   7
   8 #include <list>
   9 #include <queue>
  10 #include <vector>
  11
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/threading/thread_checker.h"
  14 #include "base/timer/timer.h"
  15 #include "base/tuple.h"
  16 #include "content/common/content_export.h"
  17 #include "media/base/android/media_codec_bridge.h"
  18 #include "media/video/video_encode_accelerator.h"
  19
  20 namespace media {
  21 class BitstreamBuffer;
  22 }  // namespace media
  23
  24 namespace content {
  25
  26 // Android-specific implementation of media::VideoEncodeAccelerator, enabling
  27 // hardware-acceleration of video encoding, based on Android's MediaCodec class
  28 // (http://developer.android.com/reference/android/media/MediaCodec.html).  This
  29 // class expects to live and be called on a single thread (the GPU process'
  30 // ChildThread).
  31 class CONTENT_EXPORT AndroidVideoEncodeAccelerator
  32     : public media::VideoEncodeAccelerator {
  33  public:
  34   AndroidVideoEncodeAccelerator();
  35   virtual ~AndroidVideoEncodeAccelerator();
  36
  37   // media::VideoEncodeAccelerator implementation.
  38   virtual std::vector<media::VideoEncodeAccelerator::SupportedProfile>
  39       GetSupportedProfiles() OVERRIDE;
  40   virtual bool Initialize(media::VideoFrame::Format format,
  41                           const gfx::Size& input_visible_size,
  42                           media::VideoCodecProfile output_profile,
  43                           uint32 initial_bitrate,
  44                           Client* client) OVERRIDE;
  45   virtual void Encode(const scoped_refptr<media::VideoFrame>& frame,
  46                       bool force_keyframe) OVERRIDE;
  47   virtual void UseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer)
  48       OVERRIDE;
  49   virtual void RequestEncodingParametersChange(uint32 bitrate,
  50                                                uint32 framerate) OVERRIDE;
  51   virtual void Destroy() OVERRIDE;
  52
  53  private:
  54   enum {
  55     // Arbitrary choice.
  56     INITIAL_FRAMERATE = 30,
  57     // Until there are non-realtime users, no need for unrequested I-frames.
  58     IFRAME_INTERVAL = kint32max,
  59   };
  60
  61   // Impedance-mismatch fixers: MediaCodec is a poll-based API but VEA is a
  62   // push-based API; these methods turn the crank to make the two work together.
  63   void DoIOTask();
  64   void QueueInput();
  65   void DequeueOutput();
  66
  67   // Returns true if we don't need more or bigger output buffers.
  68   bool DoOutputBuffersSuffice();
  69
  70   // Start & stop |io_timer_| if the time seems right.
  71   void MaybeStartIOTimer();
  72   void MaybeStopIOTimer();
  73
  74   // Used to DCHECK that we are called on the correct thread.
  75   base::ThreadChecker thread_checker_;
  76
  77   // VideoDecodeAccelerator::Client callbacks go here.  Invalidated once any
  78   // error triggers.
  79   scoped_ptr<base::WeakPtrFactory<Client> > client_ptr_factory_;
  80
  81   scoped_ptr<media::VideoCodecBridge> media_codec_;
  82
  83   // Bitstream buffers waiting to be populated & returned to the client.
  84   std::vector<media::BitstreamBuffer> available_bitstream_buffers_;
  85
  86   // Frames waiting to be passed to the codec, queued until an input buffer is
  87   // available.  Each element is a tuple of <Frame, key_frame, enqueue_time>.
  88   typedef std::queue<
  89       Tuple3<scoped_refptr<media::VideoFrame>, bool, base::Time> >
  90       PendingFrames;
  91   PendingFrames pending_frames_;
  92
  93   // Repeating timer responsible for draining pending IO to the codec.
  94   base::RepeatingTimer<AndroidVideoEncodeAccelerator> io_timer_;
  95
  96   // The difference between number of buffers queued & dequeued at the codec.
  97   int32 num_buffers_at_codec_;
  98
  99   // A monotonically-growing value, used as a fake timestamp just to keep things
 100   // appearing to move forward.
 101   base::TimeDelta fake_input_timestamp_;
 102
 103   // Number of requested output buffers and their capacity.
 104   int num_output_buffers_;          // -1 until RequireBitstreamBuffers.
 105   size_t output_buffers_capacity_;  // 0 until RequireBitstreamBuffers.
 106
 107   uint32 last_set_bitrate_;  // In bps.
 108
 109   DISALLOW_COPY_AND_ASSIGN(AndroidVideoEncodeAccelerator);
 110 };
 111
 112 }  // namespace content
 113
 114 #endif  // CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_