Home | History | Annotate | Download | only in media 
      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   explicit AndroidVideoEncodeAccelerator(
     35       media::VideoEncodeAccelerator::Client* client);
     36   virtual ~AndroidVideoEncodeAccelerator();
     37 
     38   static std::vector<media::VideoEncodeAccelerator::SupportedProfile>
     39       GetSupportedProfiles();
     40 
     41   // media::VideoEncodeAccelerator implementation.
     42   virtual void Initialize(media::VideoFrame::Format format,
     43                           const gfx::Size& input_visible_size,
     44                           media::VideoCodecProfile output_profile,
     45                           uint32 initial_bitrate) 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   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_
    116