1// Copyright (c) 2012 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// This file contains an implementation of VideoDecoderAccelerator
6// that utilizes hardware video decoder present on Intel CPUs.
7
8#ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
9#define CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
10
11#include <map>
12#include <queue>
13#include <utility>
14#include <vector>
15
16#include "base/logging.h"
17#include "base/memory/linked_ptr.h"
18#include "base/memory/shared_memory.h"
19#include "base/memory/weak_ptr.h"
20#include "base/message_loop/message_loop.h"
21#include "base/synchronization/condition_variable.h"
22#include "base/synchronization/lock.h"
23#include "base/threading/non_thread_safe.h"
24#include "base/threading/thread.h"
25#include "content/common/content_export.h"
26#include "content/common/gpu/media/vaapi_h264_decoder.h"
27#include "content/common/gpu/media/vaapi_wrapper.h"
28#include "media/base/bitstream_buffer.h"
29#include "media/video/picture.h"
30#include "media/video/video_decode_accelerator.h"
31#include "ui/gl/gl_bindings.h"
32
33namespace content {
34
35// Class to provide video decode acceleration for Intel systems with hardware
36// support for it, and on which libva is available.
37// Decoding tasks are performed in a separate decoding thread.
38//
39// Threading/life-cycle: this object is created & destroyed on the GPU
40// ChildThread.  A few methods on it are called on the decoder thread which is
41// stopped during |this->Destroy()|, so any tasks posted to the decoder thread
42// can assume |*this| is still alive.  See |weak_this_| below for more details.
43class CONTENT_EXPORT VaapiVideoDecodeAccelerator
44    : public media::VideoDecodeAccelerator {
45 public:
46  VaapiVideoDecodeAccelerator(
47      Display* x_display,
48      const base::Callback<bool(void)>& make_context_current);
49  virtual ~VaapiVideoDecodeAccelerator();
50
51  // media::VideoDecodeAccelerator implementation.
52  virtual bool Initialize(media::VideoCodecProfile profile,
53                          Client* client) OVERRIDE;
54  virtual void Decode(const media::BitstreamBuffer& bitstream_buffer) OVERRIDE;
55  virtual void AssignPictureBuffers(
56      const std::vector<media::PictureBuffer>& buffers) OVERRIDE;
57  virtual void ReusePictureBuffer(int32 picture_buffer_id) OVERRIDE;
58  virtual void Flush() OVERRIDE;
59  virtual void Reset() OVERRIDE;
60  virtual void Destroy() OVERRIDE;
61  virtual bool CanDecodeOnIOThread() OVERRIDE;
62
63private:
64  // Notify the client that an error has occurred and decoding cannot continue.
65  void NotifyError(Error error);
66
67  // Map the received input buffer into this process' address space and
68  // queue it for decode.
69  void MapAndQueueNewInputBuffer(
70      const media::BitstreamBuffer& bitstream_buffer);
71
72  // Get a new input buffer from the queue and set it up in decoder. This will
73  // sleep if no input buffers are available. Return true if a new buffer has
74  // been set up, false if an early exit has been requested (due to initiated
75  // reset/flush/destroy).
76  bool GetInputBuffer_Locked();
77
78  // Signal the client that the current buffer has been read and can be
79  // returned. Will also release the mapping.
80  void ReturnCurrInputBuffer_Locked();
81
82  // Pass one or more output buffers to the decoder. This will sleep
83  // if no buffers are available. Return true if buffers have been set up or
84  // false if an early exit has been requested (due to initiated
85  // reset/flush/destroy).
86  bool FeedDecoderWithOutputSurfaces_Locked();
87
88  // Continue decoding given input buffers and sleep waiting for input/output
89  // as needed. Will exit if a new set of surfaces or reset/flush/destroy
90  // is requested.
91  void DecodeTask();
92
93  // Scheduled after receiving a flush request and executed after the current
94  // decoding task finishes decoding pending inputs. Makes the decoder return
95  // all remaining output pictures and puts it in an idle state, ready
96  // to resume if needed and schedules a FinishFlush.
97  void FlushTask();
98
99  // Scheduled by the FlushTask after decoder is flushed to put VAVDA into idle
100  // state and notify the client that flushing has been finished.
101  void FinishFlush();
102
103  // Scheduled after receiving a reset request and executed after the current
104  // decoding task finishes decoding the current frame. Puts the decoder into
105  // an idle state, ready to resume if needed, discarding decoded but not yet
106  // outputted pictures (decoder keeps ownership of their associated picture
107  // buffers). Schedules a FinishReset afterwards.
108  void ResetTask();
109
110  // Scheduled by ResetTask after it's done putting VAVDA into an idle state.
111  // Drops remaining input buffers and notifies the client that reset has been
112  // finished.
113  void FinishReset();
114
115  // Helper for Destroy(), doing all the actual work except for deleting self.
116  void Cleanup();
117
118  // Get a usable framebuffer configuration for use in binding textures
119  // or return false on failure.
120  bool InitializeFBConfig();
121
122  // Callback for the decoder to execute when it wants us to output given
123  // |va_surface|.
124  void SurfaceReady(int32 input_id, const scoped_refptr<VASurface>& va_surface);
125
126  // Represents a texture bound to an X Pixmap for output purposes.
127  class TFPPicture;
128
129  // Callback to be executed once we have a |va_surface| to be output and
130  // an available |tfp_picture| to use for output.
131  // Puts contents of |va_surface| into given |tfp_picture|, releases the
132  // surface and passes the resulting picture to client for output.
133  void OutputPicture(const scoped_refptr<VASurface>& va_surface,
134                     int32 input_id,
135                     TFPPicture* tfp_picture);
136
137  // Try to OutputPicture() if we have both a ready surface and picture.
138  void TryOutputSurface();
139
140  // Called when a VASurface is no longer in use by the decoder or is not being
141  // synced/waiting to be synced to a picture. Returns it to available surfaces
142  // pool.
143  void RecycleVASurfaceID(VASurfaceID va_surface_id);
144
145  // Initiate wait cycle for surfaces to be released before we release them
146  // and allocate new ones, as requested by the decoder.
147  void InitiateSurfaceSetChange(size_t num_pics, gfx::Size size);
148  // Check if the surfaces have been released or post ourselves for later.
149  void TryFinishSurfaceSetChange();
150
151  // Client-provided X/GLX state.
152  Display* x_display_;
153  base::Callback<bool(void)> make_context_current_;
154  GLXFBConfig fb_config_;
155
156  // VAVDA state.
157  enum State {
158    // Initialize() not called yet or failed.
159    kUninitialized,
160    // DecodeTask running.
161    kDecoding,
162    // Resetting, waiting for decoder to finish current task and cleanup.
163    kResetting,
164    // Flushing, waiting for decoder to finish current task and cleanup.
165    kFlushing,
166    // Idle, decoder in state ready to start/resume decoding.
167    kIdle,
168    // Destroying, waiting for the decoder to finish current task.
169    kDestroying,
170  };
171
172  // Protects input buffer and surface queues and state_.
173  base::Lock lock_;
174  State state_;
175
176  // An input buffer awaiting consumption, provided by the client.
177  struct InputBuffer {
178    InputBuffer();
179    ~InputBuffer();
180
181    int32 id;
182    size_t size;
183    scoped_ptr<base::SharedMemory> shm;
184  };
185
186  // Queue for incoming input buffers.
187  typedef std::queue<linked_ptr<InputBuffer> > InputBuffers;
188  InputBuffers input_buffers_;
189  // Signalled when input buffers are queued onto the input_buffers_ queue.
190  base::ConditionVariable input_ready_;
191
192  // Current input buffer at decoder.
193  linked_ptr<InputBuffer> curr_input_buffer_;
194
195  // Queue for incoming output buffers (texture ids).
196  typedef std::queue<int32> OutputBuffers;
197  OutputBuffers output_buffers_;
198
199  typedef std::map<int32, linked_ptr<TFPPicture> > TFPPictures;
200  // All allocated TFPPictures, regardless of their current state. TFPPictures
201  // are allocated once and destroyed at the end of decode.
202  TFPPictures tfp_pictures_;
203
204  // Return a TFPPicture associated with given client-provided id.
205  TFPPicture* TFPPictureById(int32 picture_buffer_id);
206
207  // VA Surfaces no longer in use that can be passed back to the decoder for
208  // reuse, once it requests them.
209  std::list<VASurfaceID> available_va_surfaces_;
210  // Signalled when output surfaces are queued onto the available_va_surfaces_
211  // queue.
212  base::ConditionVariable surfaces_available_;
213
214  // Pending output requests from the decoder. When it indicates that we should
215  // output a surface and we have an available TFPPicture (i.e. texture) ready
216  // to use, we'll execute the callback passing the TFPPicture. The callback
217  // will put the contents of the surface into the picture and return it to
218  // the client, releasing the surface as well.
219  // If we don't have any available TFPPictures at the time when the decoder
220  // requests output, we'll store the request on pending_output_cbs_ queue for
221  // later and run it once the client gives us more textures
222  // via ReusePictureBuffer().
223  typedef base::Callback<void(TFPPicture*)> OutputCB;
224  std::queue<OutputCB> pending_output_cbs_;
225
226  // ChildThread's message loop
227  base::MessageLoop* message_loop_;
228
229  // WeakPtr<> pointing to |this| for use in posting tasks from the decoder
230  // thread back to the ChildThread.  Because the decoder thread is a member of
231  // this class, any task running on the decoder thread is guaranteed that this
232  // object is still alive.  As a result, tasks posted from ChildThread to
233  // decoder thread should use base::Unretained(this), and tasks posted from the
234  // decoder thread to the ChildThread should use |weak_this_|.
235  base::WeakPtr<VaapiVideoDecodeAccelerator> weak_this_;
236
237  // Callback used when creating VASurface objects.
238  VASurface::ReleaseCB va_surface_release_cb_;
239
240  // To expose client callbacks from VideoDecodeAccelerator.
241  // NOTE: all calls to these objects *MUST* be executed on message_loop_.
242  scoped_ptr<base::WeakPtrFactory<Client> > client_ptr_factory_;
243  base::WeakPtr<Client> client_;
244
245  scoped_ptr<VaapiWrapper> vaapi_wrapper_;
246
247  // Comes after vaapi_wrapper_ to ensure its destructor is executed before
248  // vaapi_wrapper_ is destroyed.
249  scoped_ptr<VaapiH264Decoder> decoder_;
250  base::Thread decoder_thread_;
251  // Use this to post tasks to |decoder_thread_| instead of
252  // |decoder_thread_.message_loop()| because the latter will be NULL once
253  // |decoder_thread_.Stop()| returns.
254  scoped_refptr<base::MessageLoopProxy> decoder_thread_proxy_;
255
256  int num_frames_at_client_;
257  int num_stream_bufs_at_decoder_;
258
259  // Whether we are waiting for any pending_output_cbs_ to be run before
260  // NotifyingFlushDone.
261  bool finish_flush_pending_;
262
263  // Decoder requested a new surface set and we are waiting for all the surfaces
264  // to be returned before we can free them.
265  bool awaiting_va_surfaces_recycle_;
266
267  // Last requested number/resolution of output picture buffers.
268  size_t requested_num_pics_;
269  gfx::Size requested_pic_size_;
270
271  // The WeakPtrFactory for |weak_this_|.
272  base::WeakPtrFactory<VaapiVideoDecodeAccelerator> weak_this_factory_;
273
274  DISALLOW_COPY_AND_ASSIGN(VaapiVideoDecodeAccelerator);
275};
276
277}  // namespace content
278
279#endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
280