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/services/mojo_renderer_service.h" | 5 #include "media/mojo/services/mojo_renderer_service.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "media/base/audio_renderer_sink.h" | 10 #include "media/base/audio_renderer_sink.h" |
(...skipping 11 matching lines...) Expand all Loading... |
22 | 22 |
23 MojoRendererService::MojoRendererService( | 23 MojoRendererService::MojoRendererService( |
24 base::WeakPtr<MojoCdmServiceContext> mojo_cdm_service_context, | 24 base::WeakPtr<MojoCdmServiceContext> mojo_cdm_service_context, |
25 scoped_refptr<AudioRendererSink> audio_sink, | 25 scoped_refptr<AudioRendererSink> audio_sink, |
26 std::unique_ptr<VideoRendererSink> video_sink, | 26 std::unique_ptr<VideoRendererSink> video_sink, |
27 std::unique_ptr<media::Renderer> renderer, | 27 std::unique_ptr<media::Renderer> renderer, |
28 mojo::InterfaceRequest<mojom::Renderer> request) | 28 mojo::InterfaceRequest<mojom::Renderer> request) |
29 : binding_(this, std::move(request)), | 29 : binding_(this, std::move(request)), |
30 mojo_cdm_service_context_(mojo_cdm_service_context), | 30 mojo_cdm_service_context_(mojo_cdm_service_context), |
31 state_(STATE_UNINITIALIZED), | 31 state_(STATE_UNINITIALIZED), |
| 32 playback_rate_(0), |
32 audio_sink_(std::move(audio_sink)), | 33 audio_sink_(std::move(audio_sink)), |
33 video_sink_(std::move(video_sink)), | 34 video_sink_(std::move(video_sink)), |
34 renderer_(std::move(renderer)), | 35 renderer_(std::move(renderer)), |
35 weak_factory_(this) { | 36 weak_factory_(this) { |
36 DVLOG(1) << __FUNCTION__; | 37 DVLOG(1) << __FUNCTION__; |
37 DCHECK(renderer_); | 38 DCHECK(renderer_); |
38 | 39 |
39 weak_this_ = weak_factory_.GetWeakPtr(); | 40 weak_this_ = weak_factory_.GetWeakPtr(); |
40 } | 41 } |
41 | 42 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
80 | 81 |
81 void MojoRendererService::StartPlayingFrom(base::TimeDelta time_delta) { | 82 void MojoRendererService::StartPlayingFrom(base::TimeDelta time_delta) { |
82 DVLOG(2) << __FUNCTION__ << ": " << time_delta; | 83 DVLOG(2) << __FUNCTION__ << ": " << time_delta; |
83 renderer_->StartPlayingFrom(time_delta); | 84 renderer_->StartPlayingFrom(time_delta); |
84 SchedulePeriodicMediaTimeUpdates(); | 85 SchedulePeriodicMediaTimeUpdates(); |
85 } | 86 } |
86 | 87 |
87 void MojoRendererService::SetPlaybackRate(double playback_rate) { | 88 void MojoRendererService::SetPlaybackRate(double playback_rate) { |
88 DVLOG(2) << __FUNCTION__ << ": " << playback_rate; | 89 DVLOG(2) << __FUNCTION__ << ": " << playback_rate; |
89 DCHECK(state_ == STATE_PLAYING || state_ == STATE_ERROR); | 90 DCHECK(state_ == STATE_PLAYING || state_ == STATE_ERROR); |
| 91 playback_rate_ = playback_rate; |
90 renderer_->SetPlaybackRate(playback_rate); | 92 renderer_->SetPlaybackRate(playback_rate); |
91 } | 93 } |
92 | 94 |
93 void MojoRendererService::SetVolume(float volume) { | 95 void MojoRendererService::SetVolume(float volume) { |
94 renderer_->SetVolume(volume); | 96 renderer_->SetVolume(volume); |
95 } | 97 } |
96 | 98 |
97 void MojoRendererService::SetCdm(int32_t cdm_id, | 99 void MojoRendererService::SetCdm(int32_t cdm_id, |
98 const SetCdmCallback& callback) { | 100 const SetCdmCallback& callback) { |
99 if (!mojo_cdm_service_context_) { | 101 if (!mojo_cdm_service_context_) { |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
181 state_ = STATE_ERROR; | 183 state_ = STATE_ERROR; |
182 callback.Run(false); | 184 callback.Run(false); |
183 return; | 185 return; |
184 } | 186 } |
185 | 187 |
186 state_ = STATE_PLAYING; | 188 state_ = STATE_PLAYING; |
187 callback.Run(true); | 189 callback.Run(true); |
188 } | 190 } |
189 | 191 |
190 void MojoRendererService::UpdateMediaTime(bool force) { | 192 void MojoRendererService::UpdateMediaTime(bool force) { |
191 base::TimeDelta media_time = renderer_->GetMediaTime(); | 193 const base::TimeDelta media_time = renderer_->GetMediaTime(); |
192 if (!force && media_time == last_media_time_) | 194 if (!force && media_time == last_media_time_) |
193 return; | 195 return; |
194 | 196 |
195 client_->OnTimeUpdate(media_time, media_time); | 197 base::TimeDelta max_time = media_time; |
| 198 // Allow some slop to account for delays in scheduling time update tasks. |
| 199 if (time_update_timer_.IsRunning() && (playback_rate_ > 0)) |
| 200 max_time += base::TimeDelta::FromMilliseconds(2 * kTimeUpdateIntervalMs); |
| 201 |
| 202 client_->OnTimeUpdate(media_time, max_time, base::TimeTicks::Now()); |
196 last_media_time_ = media_time; | 203 last_media_time_ = media_time; |
197 } | 204 } |
198 | 205 |
199 void MojoRendererService::CancelPeriodicMediaTimeUpdates() { | 206 void MojoRendererService::CancelPeriodicMediaTimeUpdates() { |
200 DVLOG(2) << __FUNCTION__; | 207 DVLOG(2) << __FUNCTION__; |
| 208 |
| 209 time_update_timer_.Stop(); |
201 UpdateMediaTime(false); | 210 UpdateMediaTime(false); |
202 time_update_timer_.Stop(); | |
203 } | 211 } |
204 | 212 |
205 void MojoRendererService::SchedulePeriodicMediaTimeUpdates() { | 213 void MojoRendererService::SchedulePeriodicMediaTimeUpdates() { |
206 DVLOG(2) << __FUNCTION__; | 214 DVLOG(2) << __FUNCTION__; |
| 215 |
207 UpdateMediaTime(true); | 216 UpdateMediaTime(true); |
208 time_update_timer_.Start( | 217 time_update_timer_.Start( |
209 FROM_HERE, | 218 FROM_HERE, base::TimeDelta::FromMilliseconds(kTimeUpdateIntervalMs), |
210 base::TimeDelta::FromMilliseconds(kTimeUpdateIntervalMs), | |
211 base::Bind(&MojoRendererService::UpdateMediaTime, weak_this_, false)); | 219 base::Bind(&MojoRendererService::UpdateMediaTime, weak_this_, false)); |
212 } | 220 } |
213 | 221 |
214 void MojoRendererService::OnFlushCompleted(const FlushCallback& callback) { | 222 void MojoRendererService::OnFlushCompleted(const FlushCallback& callback) { |
215 DVLOG(1) << __FUNCTION__; | 223 DVLOG(1) << __FUNCTION__; |
216 DCHECK_EQ(state_, STATE_FLUSHING); | 224 DCHECK_EQ(state_, STATE_FLUSHING); |
217 state_ = STATE_PLAYING; | 225 state_ = STATE_PLAYING; |
218 callback.Run(); | 226 callback.Run(); |
219 } | 227 } |
220 | 228 |
221 void MojoRendererService::OnCdmAttached( | 229 void MojoRendererService::OnCdmAttached( |
222 scoped_refptr<MediaKeys> cdm, | 230 scoped_refptr<MediaKeys> cdm, |
223 const base::Callback<void(bool)>& callback, | 231 const base::Callback<void(bool)>& callback, |
224 bool success) { | 232 bool success) { |
225 DVLOG(1) << __FUNCTION__ << "(" << success << ")"; | 233 DVLOG(1) << __FUNCTION__ << "(" << success << ")"; |
226 | 234 |
227 if (success) | 235 if (success) |
228 cdm_ = cdm; | 236 cdm_ = cdm; |
229 | 237 |
230 callback.Run(success); | 238 callback.Run(success); |
231 } | 239 } |
232 | 240 |
233 } // namespace media | 241 } // namespace media |
OLD | NEW |