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