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.
5 #ifndef CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
6 #define CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
14 #include "base/basictypes.h"
15 #include "base/gtest_prod_util.h"
16 #include "base/memory/weak_ptr.h"
17 #include "base/synchronization/lock.h"
18 #include "base/threading/thread.h"
19 #include "content/common/content_export.h"
20 #include "media/base/bitstream_buffer.h"
21 #include "media/base/video_decoder.h"
22 #include "media/video/picture.h"
23 #include "media/video/video_decode_accelerator.h"
24 #include "third_party/webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
28 class MessageLoopProxy
;
33 class GpuVideoAcceleratorFactories
;
38 // This class uses hardware accelerated video decoder to decode video for
39 // WebRTC. |vda_message_loop_| is the message loop proxy of the media thread,
40 // which VDA::Client methods run on. webrtc::VideoDecoder methods run on WebRTC
41 // DecodingThread or Chrome_libJingle_WorkerThread, which are trampolined to
42 // |vda_message_loop_|. Decode() is non-blocking and queues the buffers. Decoded
43 // frames are delivered to WebRTC on |vda_message_loop_|.
44 class CONTENT_EXPORT RTCVideoDecoder
45 : NON_EXPORTED_BASE(public webrtc::VideoDecoder
),
46 public media::VideoDecodeAccelerator::Client
{
48 virtual ~RTCVideoDecoder();
50 // Creates a RTCVideoDecoder. Returns NULL if failed. The video decoder will
51 // run on the message loop of |factories|.
52 static scoped_ptr
<RTCVideoDecoder
> Create(
53 webrtc::VideoCodecType type
,
54 const scoped_refptr
<media::GpuVideoAcceleratorFactories
>& factories
);
56 // webrtc::VideoDecoder implementation.
57 // Called on WebRTC DecodingThread.
58 virtual int32_t InitDecode(const webrtc::VideoCodec
* codecSettings
,
59 int32_t numberOfCores
) OVERRIDE
;
60 // Called on WebRTC DecodingThread.
61 virtual int32_t Decode(
62 const webrtc::EncodedImage
& inputImage
,
64 const webrtc::RTPFragmentationHeader
* fragmentation
,
65 const webrtc::CodecSpecificInfo
* codecSpecificInfo
= NULL
,
66 int64_t renderTimeMs
= -1) OVERRIDE
;
67 // Called on WebRTC DecodingThread.
68 virtual int32_t RegisterDecodeCompleteCallback(
69 webrtc::DecodedImageCallback
* callback
) OVERRIDE
;
70 // Called on Chrome_libJingle_WorkerThread. The child thread is blocked while
72 virtual int32_t Release() OVERRIDE
;
73 // Called on Chrome_libJingle_WorkerThread. The child thread is blocked while
75 virtual int32_t Reset() OVERRIDE
;
77 // VideoDecodeAccelerator::Client implementation.
78 virtual void ProvidePictureBuffers(uint32 count
,
79 const gfx::Size
& size
,
80 uint32 texture_target
) OVERRIDE
;
81 virtual void DismissPictureBuffer(int32 id
) OVERRIDE
;
82 virtual void PictureReady(const media::Picture
& picture
) OVERRIDE
;
83 virtual void NotifyEndOfBitstreamBuffer(int32 id
) OVERRIDE
;
84 virtual void NotifyFlushDone() OVERRIDE
;
85 virtual void NotifyResetDone() OVERRIDE
;
86 virtual void NotifyError(media::VideoDecodeAccelerator::Error error
) OVERRIDE
;
90 // Metadata of a bitstream buffer.
92 BufferData(int32 bitstream_buffer_id
,
99 int32 bitstream_buffer_id
;
100 uint32_t timestamp
; // in 90KHz
103 size_t size
; // buffer size
106 FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest
, IsBufferAfterReset
);
107 FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest
, IsFirstBufferAfterReset
);
110 const scoped_refptr
<media::GpuVideoAcceleratorFactories
>& factories
);
112 // Requests a buffer to be decoded by VDA.
113 void RequestBufferDecode();
115 bool CanMoreDecodeWorkBeDone();
117 // Returns true if bitstream buffer id |id_buffer| comes after |id_reset|.
118 // This handles the wraparound.
119 bool IsBufferAfterReset(int32 id_buffer
, int32 id_reset
);
121 // Returns true if bitstream buffer |id_buffer| is the first buffer after
123 bool IsFirstBufferAfterReset(int32 id_buffer
, int32 id_reset
);
125 // Saves a WebRTC buffer in |decode_buffers_| for decode.
126 void SaveToDecodeBuffers_Locked(const webrtc::EncodedImage
& input_image
,
127 scoped_ptr
<SHMBuffer
> shm_buffer
,
128 const BufferData
& buffer_data
);
130 // Saves a WebRTC buffer in |pending_buffers_| waiting for SHM available.
131 // Returns true on success.
132 bool SaveToPendingBuffers_Locked(const webrtc::EncodedImage
& input_image
,
133 const BufferData
& buffer_data
);
135 // Gets SHM and moves pending buffers to decode buffers.
136 void MovePendingBuffersToDecodeBuffers();
138 scoped_refptr
<media::VideoFrame
> CreateVideoFrame(
139 const media::Picture
& picture
,
140 const media::PictureBuffer
& pb
,
147 void ResetInternal();
149 // Static method is to allow it to run even after RVD is deleted.
150 static void ReleaseMailbox(
151 base::WeakPtr
<RTCVideoDecoder
> decoder
,
152 const scoped_refptr
<media::GpuVideoAcceleratorFactories
>& factories
,
153 int64 picture_buffer_id
,
155 const std::vector
<uint32
>& release_sync_points
);
156 // Tells VDA that a picture buffer can be recycled.
157 void ReusePictureBuffer(int64 picture_buffer_id
);
159 // Create |vda_| on |vda_loop_proxy_|.
160 void CreateVDA(media::VideoCodecProfile profile
, base::WaitableEvent
* waiter
);
162 void DestroyTextures();
165 // Gets a shared-memory segment of at least |min_size| bytes from
166 // |available_shm_segments_|. Returns NULL if there is no buffer or the
167 // buffer is not big enough.
168 scoped_ptr
<SHMBuffer
> GetSHM_Locked(size_t min_size
);
170 // Returns a shared-memory segment to the available pool.
171 void PutSHM_Locked(scoped_ptr
<SHMBuffer
> shm_buffer
);
173 // Allocates |number| shared memory of at least |min_size| bytes.
174 void CreateSHM(int number
, size_t min_size
);
176 // Stores the buffer metadata to |input_buffer_data_|.
177 void RecordBufferData(const BufferData
& buffer_data
);
178 // Gets the buffer metadata from |input_buffer_data_|.
179 void GetBufferData(int32 bitstream_buffer_id
,
185 // Records the result of InitDecode to UMA and returns |status|.
186 int32_t RecordInitDecodeUMA(int32_t status
);
188 // Assert the contract that this class is operated on the right thread.
189 void DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent() const;
192 UNINITIALIZED
, // The decoder has not initialized.
193 INITIALIZED
, // The decoder has initialized.
194 RESETTING
, // The decoder is being reset.
195 DECODE_ERROR
, // Decoding error happened.
198 static const int32 ID_LAST
; // maximum bitstream buffer id
199 static const int32 ID_HALF
; // half of the maximum bitstream buffer id
200 static const int32 ID_INVALID
; // indicates Reset or Release never occurred
202 // The hardware video decoder.
203 scoped_ptr
<media::VideoDecodeAccelerator
> vda_
;
205 // The size of the incoming video frames.
206 gfx::Size frame_size_
;
208 scoped_refptr
<media::GpuVideoAcceleratorFactories
> factories_
;
210 // The texture target used for decoded pictures.
211 uint32 decoder_texture_target_
;
213 // Metadata of the buffers that have been sent for decode.
214 std::list
<BufferData
> input_buffer_data_
;
216 // A map from bitstream buffer IDs to bitstream buffers that are being
217 // processed by VDA. The map owns SHM buffers.
218 std::map
<int32
, SHMBuffer
*> bitstream_buffers_in_decoder_
;
220 // A map from picture buffer IDs to texture-backed picture buffers.
221 std::map
<int32
, media::PictureBuffer
> assigned_picture_buffers_
;
223 // PictureBuffers given to us by VDA via PictureReady, which we sent forward
224 // as VideoFrames to be rendered via read_cb_, and which will be returned
225 // to us via ReusePictureBuffer.
226 typedef std::map
<int32
/* picture_buffer_id */, uint32
/* texture_id */>
227 PictureBufferTextureMap
;
228 PictureBufferTextureMap picture_buffers_at_display_
;
230 // The id that will be given to the next picture buffer.
231 int32 next_picture_buffer_id_
;
233 // Protects |state_|, |decode_complete_callback_| , |num_shm_buffers_|,
234 // |available_shm_segments_|, |pending_buffers_|, |decode_buffers_|,
235 // |next_bitstream_buffer_id_| and |reset_bitstream_buffer_id_|.
238 // The state of RTCVideoDecoder. Guarded by |lock_|.
241 // Guarded by |lock_|.
242 webrtc::DecodedImageCallback
* decode_complete_callback_
;
244 // Total number of allocated SHM buffers. Guarded by |lock_|.
245 int num_shm_buffers_
;
247 // Shared-memory buffer pool. Since allocating SHM segments requires a
248 // round-trip to the browser process, we keep allocation out of the
249 // steady-state of the decoder. The vector owns SHM buffers. Guarded by
251 std::vector
<SHMBuffer
*> available_shm_segments_
;
253 // A queue storing WebRTC encoding images (and their metadata) that are
254 // waiting for the shared memory. Guarded by |lock_|.
255 std::deque
<std::pair
<webrtc::EncodedImage
, BufferData
> > pending_buffers_
;
257 // A queue storing buffers (and their metadata) that will be sent to VDA for
258 // decode. The queue owns SHM buffers. Guarded by |lock_|.
259 std::deque
<std::pair
<SHMBuffer
*, BufferData
> > decode_buffers_
;
261 // The id that will be given to the next bitstream buffer. Guarded by |lock_|.
262 int32 next_bitstream_buffer_id_
;
264 // A buffer that has an id less than this should be dropped because Reset or
265 // Release has been called. Guarded by |lock_|.
266 int32 reset_bitstream_buffer_id_
;
268 // Must be destroyed, or invalidated, on |vda_loop_proxy_|
269 // NOTE: Weak pointers must be invalidated before all other member variables.
270 base::WeakPtrFactory
<RTCVideoDecoder
> weak_factory_
;
272 DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoder
);
275 } // namespace content
277 #endif // CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_