OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "media/mojo/clients/mojo_renderer.h" | 5 #include "media/mojo/clients/mojo_renderer.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/callback_helpers.h" | 10 #include "base/callback_helpers.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 | 21 |
22 MojoRenderer::MojoRenderer( | 22 MojoRenderer::MojoRenderer( |
23 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner, | 23 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner, |
24 std::unique_ptr<VideoOverlayFactory> video_overlay_factory, | 24 std::unique_ptr<VideoOverlayFactory> video_overlay_factory, |
25 VideoRendererSink* video_renderer_sink, | 25 VideoRendererSink* video_renderer_sink, |
26 mojom::RendererPtr remote_renderer) | 26 mojom::RendererPtr remote_renderer) |
27 : task_runner_(task_runner), | 27 : task_runner_(task_runner), |
28 video_overlay_factory_(std::move(video_overlay_factory)), | 28 video_overlay_factory_(std::move(video_overlay_factory)), |
29 video_renderer_sink_(video_renderer_sink), | 29 video_renderer_sink_(video_renderer_sink), |
30 remote_renderer_info_(remote_renderer.PassInterface()), | 30 remote_renderer_info_(remote_renderer.PassInterface()), |
31 binding_(this) { | 31 binding_(this), |
| 32 media_time_interpolator_(&media_clock_) { |
32 DVLOG(1) << __FUNCTION__; | 33 DVLOG(1) << __FUNCTION__; |
33 } | 34 } |
34 | 35 |
35 MojoRenderer::~MojoRenderer() { | 36 MojoRenderer::~MojoRenderer() { |
36 DVLOG(1) << __FUNCTION__; | 37 DVLOG(1) << __FUNCTION__; |
37 DCHECK(task_runner_->BelongsToCurrentThread()); | 38 DCHECK(task_runner_->BelongsToCurrentThread()); |
38 | 39 |
39 CancelPendingCallbacks(); | 40 CancelPendingCallbacks(); |
40 } | 41 } |
41 | 42 |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
160 DCHECK(task_runner_->BelongsToCurrentThread()); | 161 DCHECK(task_runner_->BelongsToCurrentThread()); |
161 DCHECK(remote_renderer_.is_bound()); | 162 DCHECK(remote_renderer_.is_bound()); |
162 DCHECK(!flush_cb.is_null()); | 163 DCHECK(!flush_cb.is_null()); |
163 DCHECK(flush_cb_.is_null()); | 164 DCHECK(flush_cb_.is_null()); |
164 | 165 |
165 if (encountered_error_) { | 166 if (encountered_error_) { |
166 task_runner_->PostTask(FROM_HERE, flush_cb); | 167 task_runner_->PostTask(FROM_HERE, flush_cb); |
167 return; | 168 return; |
168 } | 169 } |
169 | 170 |
| 171 { |
| 172 base::AutoLock auto_lock(lock_); |
| 173 if (media_time_interpolator_.interpolating()) |
| 174 media_time_interpolator_.StopInterpolating(); |
| 175 } |
| 176 |
170 flush_cb_ = flush_cb; | 177 flush_cb_ = flush_cb; |
171 remote_renderer_->Flush( | 178 remote_renderer_->Flush( |
172 base::Bind(&MojoRenderer::OnFlushed, base::Unretained(this))); | 179 base::Bind(&MojoRenderer::OnFlushed, base::Unretained(this))); |
173 } | 180 } |
174 | 181 |
175 void MojoRenderer::StartPlayingFrom(base::TimeDelta time) { | 182 void MojoRenderer::StartPlayingFrom(base::TimeDelta time) { |
176 DVLOG(2) << __FUNCTION__; | 183 DVLOG(2) << __FUNCTION__ << "(" << time << ")"; |
177 DCHECK(task_runner_->BelongsToCurrentThread()); | 184 DCHECK(task_runner_->BelongsToCurrentThread()); |
178 DCHECK(remote_renderer_.is_bound()); | 185 DCHECK(remote_renderer_.is_bound()); |
179 | 186 |
180 { | 187 { |
181 base::AutoLock auto_lock(lock_); | 188 base::AutoLock auto_lock(lock_); |
182 time_ = time; | 189 media_time_interpolator_.SetBounds(time, time, media_clock_.NowTicks()); |
| 190 media_time_interpolator_.StartInterpolating(); |
183 } | 191 } |
184 | 192 |
185 remote_renderer_->StartPlayingFrom(time); | 193 remote_renderer_->StartPlayingFrom(time); |
186 } | 194 } |
187 | 195 |
188 void MojoRenderer::SetPlaybackRate(double playback_rate) { | 196 void MojoRenderer::SetPlaybackRate(double playback_rate) { |
189 DVLOG(2) << __FUNCTION__; | 197 DVLOG(2) << __FUNCTION__ << "(" << playback_rate << ")"; |
190 DCHECK(task_runner_->BelongsToCurrentThread()); | 198 DCHECK(task_runner_->BelongsToCurrentThread()); |
191 DCHECK(remote_renderer_.is_bound()); | 199 DCHECK(remote_renderer_.is_bound()); |
192 | 200 |
193 remote_renderer_->SetPlaybackRate(playback_rate); | 201 remote_renderer_->SetPlaybackRate(playback_rate); |
| 202 |
| 203 { |
| 204 base::AutoLock auto_lock(lock_); |
| 205 media_time_interpolator_.SetPlaybackRate(playback_rate); |
| 206 } |
194 } | 207 } |
195 | 208 |
196 void MojoRenderer::SetVolume(float volume) { | 209 void MojoRenderer::SetVolume(float volume) { |
197 DVLOG(2) << __FUNCTION__; | 210 DVLOG(2) << __FUNCTION__ << "(" << volume << ")"; |
198 DCHECK(task_runner_->BelongsToCurrentThread()); | 211 DCHECK(task_runner_->BelongsToCurrentThread()); |
199 DCHECK(remote_renderer_.is_bound()); | 212 DCHECK(remote_renderer_.is_bound()); |
200 | 213 |
201 remote_renderer_->SetVolume(volume); | 214 remote_renderer_->SetVolume(volume); |
202 } | 215 } |
203 | 216 |
204 base::TimeDelta MojoRenderer::GetMediaTime() { | 217 base::TimeDelta MojoRenderer::GetMediaTime() { |
205 base::AutoLock auto_lock(lock_); | 218 base::AutoLock auto_lock(lock_); |
206 DVLOG(3) << __FUNCTION__ << ": " << time_.InMilliseconds() << " ms"; | 219 return media_time_interpolator_.GetInterpolatedTime(); |
207 return time_; | |
208 } | 220 } |
209 | 221 |
210 bool MojoRenderer::HasAudio() { | 222 bool MojoRenderer::HasAudio() { |
211 DVLOG(1) << __FUNCTION__; | 223 DVLOG(1) << __FUNCTION__; |
212 DCHECK(task_runner_->BelongsToCurrentThread()); | 224 DCHECK(task_runner_->BelongsToCurrentThread()); |
213 DCHECK(remote_renderer_.is_bound()); | 225 DCHECK(remote_renderer_.is_bound()); |
214 | 226 |
215 if (demuxer_stream_provider_->GetType() == DemuxerStreamProvider::Type::URL) { | 227 if (demuxer_stream_provider_->GetType() == DemuxerStreamProvider::Type::URL) { |
216 NOTIMPLEMENTED(); | 228 NOTIMPLEMENTED(); |
217 return false; | 229 return false; |
218 } | 230 } |
219 | 231 |
220 return !!demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO); | 232 return !!demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO); |
221 } | 233 } |
222 | 234 |
223 bool MojoRenderer::HasVideo() { | 235 bool MojoRenderer::HasVideo() { |
224 DVLOG(1) << __FUNCTION__; | 236 DVLOG(1) << __FUNCTION__; |
225 DCHECK(task_runner_->BelongsToCurrentThread()); | 237 DCHECK(task_runner_->BelongsToCurrentThread()); |
226 DCHECK(remote_renderer_.is_bound()); | 238 DCHECK(remote_renderer_.is_bound()); |
227 | 239 |
228 if (demuxer_stream_provider_->GetType() == DemuxerStreamProvider::Type::URL) { | 240 if (demuxer_stream_provider_->GetType() == DemuxerStreamProvider::Type::URL) { |
229 NOTIMPLEMENTED(); | 241 NOTIMPLEMENTED(); |
230 return false; | 242 return false; |
231 } | 243 } |
232 | 244 |
233 return !!demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO); | 245 return !!demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO); |
234 } | 246 } |
235 | 247 |
236 void MojoRenderer::OnTimeUpdate(base::TimeDelta time, | 248 void MojoRenderer::OnTimeUpdate(base::TimeDelta time, |
237 base::TimeDelta max_time) { | 249 base::TimeDelta max_time, |
238 DVLOG(3) << __FUNCTION__ << ": " << time << ", " << max_time; | 250 base::TimeTicks capture_time) { |
| 251 DVLOG(4) << __FUNCTION__ << "(" << time << ", " << max_time << ", " |
| 252 << capture_time << ")"; |
239 DCHECK(task_runner_->BelongsToCurrentThread()); | 253 DCHECK(task_runner_->BelongsToCurrentThread()); |
240 | 254 |
241 base::AutoLock auto_lock(lock_); | 255 base::AutoLock auto_lock(lock_); |
242 time_ = time; | 256 media_time_interpolator_.SetBounds(time, max_time, capture_time); |
243 } | 257 } |
244 | 258 |
245 void MojoRenderer::OnBufferingStateChange(mojom::BufferingState state) { | 259 void MojoRenderer::OnBufferingStateChange(mojom::BufferingState state) { |
246 DVLOG(2) << __FUNCTION__; | 260 DVLOG(2) << __FUNCTION__; |
247 DCHECK(task_runner_->BelongsToCurrentThread()); | 261 DCHECK(task_runner_->BelongsToCurrentThread()); |
248 client_->OnBufferingStateChange(static_cast<media::BufferingState>(state)); | 262 client_->OnBufferingStateChange(static_cast<media::BufferingState>(state)); |
249 } | 263 } |
250 | 264 |
251 void MojoRenderer::OnEnded() { | 265 void MojoRenderer::OnEnded() { |
252 DVLOG(1) << __FUNCTION__; | 266 DVLOG(1) << __FUNCTION__; |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
381 base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED); | 395 base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED); |
382 | 396 |
383 if (!flush_cb_.is_null()) | 397 if (!flush_cb_.is_null()) |
384 base::ResetAndReturn(&flush_cb_).Run(); | 398 base::ResetAndReturn(&flush_cb_).Run(); |
385 | 399 |
386 if (!cdm_attached_cb_.is_null()) | 400 if (!cdm_attached_cb_.is_null()) |
387 base::ResetAndReturn(&cdm_attached_cb_).Run(false); | 401 base::ResetAndReturn(&cdm_attached_cb_).Run(false); |
388 } | 402 } |
389 | 403 |
390 } // namespace media | 404 } // namespace media |
OLD | NEW |