OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/media/rtc_video_decoder_factory_tv.h" | 5 #include "content/renderer/media/rtc_video_decoder_factory_tv.h" |
6 | 6 |
7 #include "base/callback_helpers.h" | 7 #include "base/callback_helpers.h" |
8 #include "content/renderer/media/rtc_video_decoder_bridge_tv.h" | 8 #include "content/renderer/media/rtc_video_decoder_bridge_tv.h" |
9 #include "media/base/audio_decoder_config.h" | 9 #include "media/base/audio_decoder_config.h" |
10 #include "media/base/bind_to_loop.h" | 10 #include "media/base/bind_to_loop.h" |
(...skipping 13 matching lines...) Expand all Loading... |
24 virtual ~RTCDemuxerStream(); | 24 virtual ~RTCDemuxerStream(); |
25 | 25 |
26 // DemuxerStream implementation. | 26 // DemuxerStream implementation. |
27 virtual void Read(const ReadCB& read_cb) OVERRIDE; | 27 virtual void Read(const ReadCB& read_cb) OVERRIDE; |
28 virtual media::AudioDecoderConfig audio_decoder_config() OVERRIDE; | 28 virtual media::AudioDecoderConfig audio_decoder_config() OVERRIDE; |
29 virtual media::VideoDecoderConfig video_decoder_config() OVERRIDE; | 29 virtual media::VideoDecoderConfig video_decoder_config() OVERRIDE; |
30 virtual Type type() OVERRIDE; | 30 virtual Type type() OVERRIDE; |
31 virtual void EnableBitstreamConverter() OVERRIDE; | 31 virtual void EnableBitstreamConverter() OVERRIDE; |
32 | 32 |
33 void QueueBuffer(scoped_refptr<media::DecoderBuffer> buffer, | 33 void QueueBuffer(scoped_refptr<media::DecoderBuffer> buffer, |
34 const base::Closure& done_cb, | |
35 const gfx::Size& new_size); | 34 const gfx::Size& new_size); |
36 void Destroy(); | 35 void Destroy(); |
37 | 36 |
38 private: | 37 private: |
39 struct BufferEntry { | 38 struct BufferEntry { |
40 BufferEntry(const scoped_refptr<media::DecoderBuffer>& decoder_buffer_param, | 39 BufferEntry(const scoped_refptr<media::DecoderBuffer>& decoder_buffer_param, |
41 const base::Closure& done_cb_param, | |
42 const gfx::Size& new_size_param) | 40 const gfx::Size& new_size_param) |
43 : decoder_buffer(decoder_buffer_param), | 41 : decoder_buffer(decoder_buffer_param), |
44 done_cb(done_cb_param), | |
45 new_size(new_size_param) {} | 42 new_size(new_size_param) {} |
46 | 43 |
47 scoped_refptr<media::DecoderBuffer> decoder_buffer; | 44 scoped_refptr<media::DecoderBuffer> decoder_buffer; |
48 base::Closure done_cb; | |
49 // When |!new_size.isEmpty()|, it means that config change with new size | 45 // When |!new_size.isEmpty()|, it means that config change with new size |
50 // |new_size| happened. | 46 // |new_size| happened. |
51 gfx::Size new_size; | 47 gfx::Size new_size; |
52 }; | 48 }; |
53 | 49 |
54 void RunReadCallback_Locked(); | 50 void RunReadCallback_Locked(); |
55 | 51 |
56 base::Lock lock_; | 52 base::Lock lock_; |
57 bool is_destroyed_; | 53 bool is_destroyed_; |
58 std::queue<BufferEntry> buffer_queue_; | 54 std::queue<BufferEntry> buffer_queue_; |
59 ReadCB read_cb_; | 55 ReadCB read_cb_; |
60 base::Closure pending_done_cb_; | |
61 | 56 |
62 media::AudioDecoderConfig dummy_audio_decoder_config_; | 57 media::AudioDecoderConfig dummy_audio_decoder_config_; |
63 media::VideoDecoderConfig video_decoder_config_; | 58 media::VideoDecoderConfig video_decoder_config_; |
64 talk_base::RateTracker frame_rate_tracker_; | 59 talk_base::RateTracker frame_rate_tracker_; |
65 }; | 60 }; |
66 | 61 |
67 RTCDemuxerStream::RTCDemuxerStream(const gfx::Size& size) | 62 RTCDemuxerStream::RTCDemuxerStream(const gfx::Size& size) |
68 : is_destroyed_(false), | 63 : is_destroyed_(false), |
69 video_decoder_config_(media::kCodecVP8, | 64 video_decoder_config_(media::kCodecVP8, |
70 media::VP8PROFILE_MAIN, | 65 media::VP8PROFILE_MAIN, |
(...skipping 15 matching lines...) Expand all Loading... |
86 media::VideoDecoderConfig RTCDemuxerStream::video_decoder_config() { | 81 media::VideoDecoderConfig RTCDemuxerStream::video_decoder_config() { |
87 base::AutoLock lock(lock_); | 82 base::AutoLock lock(lock_); |
88 return video_decoder_config_; | 83 return video_decoder_config_; |
89 } | 84 } |
90 | 85 |
91 DemuxerStream::Type RTCDemuxerStream::type() { return DemuxerStream::VIDEO; } | 86 DemuxerStream::Type RTCDemuxerStream::type() { return DemuxerStream::VIDEO; } |
92 | 87 |
93 void RTCDemuxerStream::EnableBitstreamConverter() { NOTREACHED(); } | 88 void RTCDemuxerStream::EnableBitstreamConverter() { NOTREACHED(); } |
94 | 89 |
95 void RTCDemuxerStream::QueueBuffer(scoped_refptr<media::DecoderBuffer> buffer, | 90 void RTCDemuxerStream::QueueBuffer(scoped_refptr<media::DecoderBuffer> buffer, |
96 const base::Closure& done_cb, | |
97 const gfx::Size& new_size) { | 91 const gfx::Size& new_size) { |
98 base::AutoLock lock(lock_); | 92 base::AutoLock lock(lock_); |
99 if (is_destroyed_) | 93 if (is_destroyed_) |
100 return; | 94 return; |
101 buffer_queue_.push(BufferEntry(buffer, done_cb, new_size)); | 95 buffer_queue_.push(BufferEntry(buffer, new_size)); |
102 if (buffer) | 96 if (buffer) |
103 frame_rate_tracker_.Update(1); | 97 frame_rate_tracker_.Update(1); |
104 DVLOG(1) << "frame rate received : " << frame_rate_tracker_.units_second(); | 98 DVLOG(1) << "frame rate received : " << frame_rate_tracker_.units_second(); |
105 RunReadCallback_Locked(); | 99 RunReadCallback_Locked(); |
106 } | 100 } |
107 | 101 |
108 void RTCDemuxerStream::Read(const ReadCB& read_cb) { | 102 void RTCDemuxerStream::Read(const ReadCB& read_cb) { |
109 base::AutoLock lock(lock_); | 103 base::AutoLock lock(lock_); |
110 DCHECK(read_cb_.is_null()); | 104 DCHECK(read_cb_.is_null()); |
111 if (is_destroyed_) { | 105 if (is_destroyed_) { |
112 media::BindToLoop(base::MessageLoopProxy::current(), read_cb) | 106 media::BindToLoop(base::MessageLoopProxy::current(), read_cb) |
113 .Run(DemuxerStream::kAborted, NULL); | 107 .Run(DemuxerStream::kAborted, NULL); |
114 return; | 108 return; |
115 } | 109 } |
116 // A call to |Read| operation means that |MediaSourceDelegate| is done with | |
117 // the previous buffer. | |
118 if (!pending_done_cb_.is_null()) | |
119 base::ResetAndReturn(&pending_done_cb_).Run(); | |
120 read_cb_ = media::BindToLoop(base::MessageLoopProxy::current(), read_cb); | 110 read_cb_ = media::BindToLoop(base::MessageLoopProxy::current(), read_cb); |
121 RunReadCallback_Locked(); | 111 RunReadCallback_Locked(); |
122 } | 112 } |
123 | 113 |
124 void RTCDemuxerStream::Destroy() { | 114 void RTCDemuxerStream::Destroy() { |
125 base::AutoLock lock(lock_); | 115 base::AutoLock lock(lock_); |
126 DCHECK(!is_destroyed_); | 116 DCHECK(!is_destroyed_); |
127 is_destroyed_ = true; | 117 is_destroyed_ = true; |
128 if (!read_cb_.is_null()) | 118 if (!read_cb_.is_null()) |
129 base::ResetAndReturn(&read_cb_).Run(DemuxerStream::kAborted, NULL); | 119 base::ResetAndReturn(&read_cb_).Run(DemuxerStream::kAborted, NULL); |
130 pending_done_cb_.Reset(); | |
131 while (!buffer_queue_.empty()) | 120 while (!buffer_queue_.empty()) |
132 buffer_queue_.pop(); | 121 buffer_queue_.pop(); |
133 } | 122 } |
134 | 123 |
135 void RTCDemuxerStream::RunReadCallback_Locked() { | 124 void RTCDemuxerStream::RunReadCallback_Locked() { |
136 if (read_cb_.is_null() || buffer_queue_.empty()) | 125 if (read_cb_.is_null() || buffer_queue_.empty()) |
137 return; | 126 return; |
138 | 127 |
139 BufferEntry& front = buffer_queue_.front(); | 128 BufferEntry& front = buffer_queue_.front(); |
140 if (!front.new_size.IsEmpty()) { | 129 if (!front.new_size.IsEmpty()) { |
141 // No VideoFrame actually reaches GL renderer in Google TV case. We just | 130 // No VideoFrame actually reaches GL renderer in Google TV case. We just |
142 // make coded_size == visible_rect == natural_size here. | 131 // make coded_size == visible_rect == natural_size here. |
143 video_decoder_config_.Initialize(media::kCodecVP8, | 132 video_decoder_config_.Initialize(media::kCodecVP8, |
144 media::VP8PROFILE_MAIN, | 133 media::VP8PROFILE_MAIN, |
145 media::VideoFrame::NATIVE_TEXTURE, | 134 media::VideoFrame::NATIVE_TEXTURE, |
146 front.new_size, | 135 front.new_size, |
147 gfx::Rect(front.new_size), | 136 gfx::Rect(front.new_size), |
148 front.new_size, | 137 front.new_size, |
149 NULL, | 138 NULL, |
150 0, | 139 0, |
151 false, | 140 false, |
152 false); | 141 false); |
153 base::ResetAndReturn(&read_cb_).Run(DemuxerStream::kConfigChanged, NULL); | 142 base::ResetAndReturn(&read_cb_).Run(DemuxerStream::kConfigChanged, NULL); |
154 front.new_size.SetSize(0, 0); | 143 front.new_size.SetSize(0, 0); |
155 return; | 144 return; |
156 } | 145 } |
157 DCHECK(pending_done_cb_.is_null()); | |
158 pending_done_cb_ = front.done_cb; | |
159 base::ResetAndReturn(&read_cb_).Run(DemuxerStream::kOk, front.decoder_buffer); | 146 base::ResetAndReturn(&read_cb_).Run(DemuxerStream::kOk, front.decoder_buffer); |
160 buffer_queue_.pop(); | 147 buffer_queue_.pop(); |
161 } | 148 } |
162 | 149 |
163 // RTCVideoDecoderFactoryTv ---------------------------------------------------- | 150 // RTCVideoDecoderFactoryTv ---------------------------------------------------- |
164 | 151 |
165 RTCVideoDecoderFactoryTv::RTCVideoDecoderFactoryTv() : is_acquired_(false) {} | 152 RTCVideoDecoderFactoryTv::RTCVideoDecoderFactoryTv() : is_acquired_(false) {} |
166 RTCVideoDecoderFactoryTv::~RTCVideoDecoderFactoryTv() {} | 153 RTCVideoDecoderFactoryTv::~RTCVideoDecoderFactoryTv() {} |
167 | 154 |
168 webrtc::VideoDecoder* RTCVideoDecoderFactoryTv::CreateVideoDecoder( | 155 webrtc::VideoDecoder* RTCVideoDecoderFactoryTv::CreateVideoDecoder( |
169 webrtc::VideoCodecType type) { | 156 webrtc::VideoCodecType type) { |
170 base::AutoLock lock(lock_); | 157 base::AutoLock lock(lock_); |
171 // One decoder at a time! | 158 // One decoder at a time! |
172 if (decoder_) | 159 if (decoder_) |
173 return NULL; | 160 return NULL; |
174 // Only VP8 is supported --- returning NULL will make WebRTC fall back to SW | 161 // Only VP8 is supported --- returning NULL will make WebRTC fall back to SW |
175 // decoder. | 162 // decoder. |
176 if (type != webrtc::kVideoCodecVP8) | 163 if (type != webrtc::kVideoCodecVP8) |
177 return NULL; | 164 return NULL; |
178 decoder_.reset(new RTCVideoDecoderBridgeTv(this)); | 165 decoder_.reset(new RTCVideoDecoderBridgeTv(this)); |
179 return decoder_.get(); | 166 return decoder_.get(); |
180 } | 167 } |
181 | 168 |
182 void RTCVideoDecoderFactoryTv::DestroyVideoDecoder( | 169 void RTCVideoDecoderFactoryTv::DestroyVideoDecoder( |
183 webrtc::VideoDecoder* decoder) { | 170 webrtc::VideoDecoder* decoder) { |
184 base::AutoLock lock(lock_); | 171 base::AutoLock lock(lock_); |
185 DCHECK(decoder_.get() == decoder); | 172 DCHECK_EQ(decoder_.get(), decoder); |
186 decoder_.reset(); | 173 decoder_.reset(); |
187 } | 174 } |
188 | 175 |
189 bool RTCVideoDecoderFactoryTv::AcquireDemuxer() { | 176 bool RTCVideoDecoderFactoryTv::AcquireDemuxer() { |
190 base::AutoLock lock(lock_); | 177 base::AutoLock lock(lock_); |
191 if (is_acquired_) | 178 if (is_acquired_) |
192 return false; | 179 return false; |
193 is_acquired_ = true; | 180 is_acquired_ = true; |
194 return true; | 181 return true; |
195 } | 182 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
228 void RTCVideoDecoderFactoryTv::InitializeStream(const gfx::Size& size) { | 215 void RTCVideoDecoderFactoryTv::InitializeStream(const gfx::Size& size) { |
229 base::AutoLock lock(lock_); | 216 base::AutoLock lock(lock_); |
230 DCHECK(!stream_); | 217 DCHECK(!stream_); |
231 stream_.reset(new RTCDemuxerStream(size)); | 218 stream_.reset(new RTCDemuxerStream(size)); |
232 if (!init_cb_.is_null()) | 219 if (!init_cb_.is_null()) |
233 base::ResetAndReturn(&init_cb_).Run(media::PIPELINE_OK); | 220 base::ResetAndReturn(&init_cb_).Run(media::PIPELINE_OK); |
234 } | 221 } |
235 | 222 |
236 void RTCVideoDecoderFactoryTv::QueueBuffer( | 223 void RTCVideoDecoderFactoryTv::QueueBuffer( |
237 scoped_refptr<media::DecoderBuffer> buffer, | 224 scoped_refptr<media::DecoderBuffer> buffer, |
238 const base::Closure& done_cb, | |
239 const gfx::Size& new_size) { | 225 const gfx::Size& new_size) { |
240 base::AutoLock lock(lock_); | 226 base::AutoLock lock(lock_); |
241 DCHECK(stream_); | 227 DCHECK(stream_); |
242 stream_->QueueBuffer(buffer, done_cb, new_size); | 228 stream_->QueueBuffer(buffer, new_size); |
243 } | 229 } |
244 | 230 |
245 } // namespace content | 231 } // namespace content |
OLD | NEW |