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
20namespace media {
21class BitstreamBuffer;
22}  // namespace media
23
24namespace 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).
31class 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_
115