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   static std::vector<media::VideoEncodeAccelerator::SupportedProfile>
  38       GetSupportedProfiles();
  39
  40   // media::VideoEncodeAccelerator implementation.
  41   virtual bool Initialize(media::VideoFrame::Format format,
  42                           const gfx::Size& input_visible_size,
  43                           media::VideoCodecProfile output_profile,
  44                           uint32 initial_bitrate,
  45                           Client* client) OVERRIDE;
  46   virtual void Encode(const scoped_refptr<media::VideoFrame>& frame,
  47                       bool force_keyframe) OVERRIDE;
  48   virtual void UseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer)
  49       OVERRIDE;
  50   virtual void RequestEncodingParametersChange(uint32 bitrate,
  51                                                uint32 framerate) OVERRIDE;
  52   virtual void Destroy() OVERRIDE;
  53
  54  private:
  55   enum {
  56     // Arbitrary choice.
  57     INITIAL_FRAMERATE = 30,
  58     // Until there are non-realtime users, no need for unrequested I-frames.
  59     IFRAME_INTERVAL = kint32max,
  60   };
  61
  62   // Impedance-mismatch fixers: MediaCodec is a poll-based API but VEA is a
  63   // push-based API; these methods turn the crank to make the two work together.
  64   void DoIOTask();
  65   void QueueInput();
  66   void DequeueOutput();
  67
  68   // Returns true if we don't need more or bigger output buffers.
  69   bool DoOutputBuffersSuffice();
  70
  71   // Start & stop |io_timer_| if the time seems right.
  72   void MaybeStartIOTimer();
  73   void MaybeStopIOTimer();
  74
  75   // Used to DCHECK that we are called on the correct thread.
  76   base::ThreadChecker thread_checker_;
  77
  78   // VideoDecodeAccelerator::Client callbacks go here.  Invalidated once any
  79   // error triggers.
  80   scoped_ptr<base::WeakPtrFactory<Client> > client_ptr_factory_;
  81
  82   scoped_ptr<media::VideoCodecBridge> media_codec_;
  83
  84   // Bitstream buffers waiting to be populated & returned to the client.
  85   std::vector<media::BitstreamBuffer> available_bitstream_buffers_;
  86
  87   // Frames waiting to be passed to the codec, queued until an input buffer is
  88   // available.  Each element is a tuple of <Frame, key_frame, enqueue_time>.
  89   typedef std::queue<
  90       Tuple3<scoped_refptr<media::VideoFrame>, bool, base::Time> >
  91       PendingFrames;
  92   PendingFrames pending_frames_;
  93
  94   // Repeating timer responsible for draining pending IO to the codec.
  95   base::RepeatingTimer<AndroidVideoEncodeAccelerator> io_timer_;
  96
  97   // The difference between number of buffers queued & dequeued at the codec.
  98   int32 num_buffers_at_codec_;
  99
 100   // A monotonically-growing value, used as a fake timestamp just to keep things
 101   // appearing to move forward.
 102   base::TimeDelta fake_input_timestamp_;
 103
 104   // Number of requested output buffers and their capacity.
 105   int num_output_buffers_;          // -1 until RequireBitstreamBuffers.
 106   size_t output_buffers_capacity_;  // 0 until RequireBitstreamBuffers.
 107
 108   uint32 last_set_bitrate_;  // In bps.
 109
 110   DISALLOW_COPY_AND_ASSIGN(AndroidVideoEncodeAccelerator);
 111 };
 112
 113 }  // namespace content
 114
 115 #endif  // CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_