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 "chromecast/media/cma/pipeline/media_pipeline_impl.h" | 5 #include "chromecast/media/cma/pipeline/media_pipeline_impl.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/callback.h" | 8 #include "base/callback.h" |
9 #include "base/callback_helpers.h" | 9 #include "base/callback_helpers.h" |
10 #include "base/location.h" | 10 #include "base/location.h" |
11 #include "base/logging.h" | 11 #include "base/logging.h" |
12 #include "base/single_thread_task_runner.h" | 12 #include "base/single_thread_task_runner.h" |
13 #include "base/thread_task_runner_handle.h" | 13 #include "base/thread_task_runner_handle.h" |
14 #include "base/time/time.h" | 14 #include "base/time/time.h" |
15 #include "chromecast/media/cdm/browser_cdm_cast.h" | 15 #include "chromecast/media/cdm/browser_cdm_cast.h" |
16 #include "chromecast/media/cma/backend/media_clock_device.h" | |
17 #include "chromecast/media/cma/backend/media_pipeline_device.h" | |
18 #include "chromecast/media/cma/base/buffering_controller.h" | 16 #include "chromecast/media/cma/base/buffering_controller.h" |
19 #include "chromecast/media/cma/base/buffering_state.h" | 17 #include "chromecast/media/cma/base/buffering_state.h" |
20 #include "chromecast/media/cma/base/cma_logging.h" | 18 #include "chromecast/media/cma/base/cma_logging.h" |
21 #include "chromecast/media/cma/base/coded_frame_provider.h" | 19 #include "chromecast/media/cma/base/coded_frame_provider.h" |
22 #include "chromecast/media/cma/pipeline/audio_pipeline_impl.h" | 20 #include "chromecast/media/cma/pipeline/audio_pipeline_impl.h" |
23 #include "chromecast/media/cma/pipeline/video_pipeline_impl.h" | 21 #include "chromecast/media/cma/pipeline/video_pipeline_impl.h" |
| 22 #include "chromecast/public/media/media_clock_device.h" |
| 23 #include "chromecast/public/media/media_pipeline_backend.h" |
24 #include "media/base/buffers.h" | 24 #include "media/base/buffers.h" |
25 | 25 |
26 namespace chromecast { | 26 namespace chromecast { |
27 namespace media { | 27 namespace media { |
28 | 28 |
29 namespace { | 29 namespace { |
30 | 30 |
31 // Buffering parameters when load_type is kLoadTypeUrl. | 31 // Buffering parameters when load_type is kLoadTypeUrl. |
32 const base::TimeDelta kLowBufferThresholdURL( | 32 const base::TimeDelta kLowBufferThresholdURL( |
33 base::TimeDelta::FromMilliseconds(2000)); | 33 base::TimeDelta::FromMilliseconds(2000)); |
(...skipping 29 matching lines...) Expand all Loading... |
63 thread_checker_.DetachFromThread(); | 63 thread_checker_.DetachFromThread(); |
64 } | 64 } |
65 | 65 |
66 MediaPipelineImpl::~MediaPipelineImpl() { | 66 MediaPipelineImpl::~MediaPipelineImpl() { |
67 CMALOG(kLogControl) << __FUNCTION__; | 67 CMALOG(kLogControl) << __FUNCTION__; |
68 DCHECK(thread_checker_.CalledOnValidThread()); | 68 DCHECK(thread_checker_.CalledOnValidThread()); |
69 } | 69 } |
70 | 70 |
71 void MediaPipelineImpl::Initialize( | 71 void MediaPipelineImpl::Initialize( |
72 LoadType load_type, | 72 LoadType load_type, |
73 scoped_ptr<MediaPipelineDevice> media_pipeline_device) { | 73 scoped_ptr<MediaPipelineBackend> media_pipeline_backend) { |
74 CMALOG(kLogControl) << __FUNCTION__; | 74 CMALOG(kLogControl) << __FUNCTION__; |
75 DCHECK(thread_checker_.CalledOnValidThread()); | 75 DCHECK(thread_checker_.CalledOnValidThread()); |
76 media_pipeline_device_.reset(media_pipeline_device.release()); | 76 media_pipeline_backend_.reset(media_pipeline_backend.release()); |
77 clock_device_ = media_pipeline_device_->GetMediaClockDevice(); | 77 clock_device_ = media_pipeline_backend_->GetClock(); |
78 | 78 |
79 if (load_type == kLoadTypeURL || load_type == kLoadTypeMediaSource) { | 79 if (load_type == kLoadTypeURL || load_type == kLoadTypeMediaSource) { |
80 base::TimeDelta low_threshold(kLowBufferThresholdURL); | 80 base::TimeDelta low_threshold(kLowBufferThresholdURL); |
81 base::TimeDelta high_threshold(kHighBufferThresholdURL); | 81 base::TimeDelta high_threshold(kHighBufferThresholdURL); |
82 if (load_type == kLoadTypeMediaSource) { | 82 if (load_type == kLoadTypeMediaSource) { |
83 low_threshold = kLowBufferThresholdMediaSource; | 83 low_threshold = kLowBufferThresholdMediaSource; |
84 high_threshold = kHighBufferThresholdMediaSource; | 84 high_threshold = kHighBufferThresholdMediaSource; |
85 } | 85 } |
86 scoped_refptr<BufferingConfig> buffering_config( | 86 scoped_refptr<BufferingConfig> buffering_config( |
87 new BufferingConfig(low_threshold, high_threshold)); | 87 new BufferingConfig(low_threshold, high_threshold)); |
88 buffering_controller_.reset(new BufferingController( | 88 buffering_controller_.reset(new BufferingController( |
89 buffering_config, | 89 buffering_config, |
90 base::Bind(&MediaPipelineImpl::OnBufferingNotification, weak_this_))); | 90 base::Bind(&MediaPipelineImpl::OnBufferingNotification, weak_this_))); |
91 } | 91 } |
92 | 92 |
93 audio_pipeline_.reset(new AudioPipelineImpl( | 93 audio_pipeline_.reset( |
94 media_pipeline_device_->GetAudioPipelineDevice())); | 94 new AudioPipelineImpl(media_pipeline_backend_->GetAudio())); |
95 | 95 |
96 video_pipeline_.reset(new VideoPipelineImpl( | 96 video_pipeline_.reset( |
97 media_pipeline_device_->GetVideoPipelineDevice())); | 97 new VideoPipelineImpl(media_pipeline_backend_->GetVideo())); |
98 } | 98 } |
99 | 99 |
100 void MediaPipelineImpl::SetClient(const MediaPipelineClient& client) { | 100 void MediaPipelineImpl::SetClient(const MediaPipelineClient& client) { |
101 DCHECK(thread_checker_.CalledOnValidThread()); | 101 DCHECK(thread_checker_.CalledOnValidThread()); |
102 DCHECK(!client.error_cb.is_null()); | 102 DCHECK(!client.error_cb.is_null()); |
103 DCHECK(!client.time_update_cb.is_null()); | 103 DCHECK(!client.time_update_cb.is_null()); |
104 DCHECK(!client.buffering_state_cb.is_null()); | 104 DCHECK(!client.buffering_state_cb.is_null()); |
105 client_ = client; | 105 client_ = client; |
106 } | 106 } |
107 | 107 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
159 } | 159 } |
160 | 160 |
161 void MediaPipelineImpl::StartPlayingFrom(base::TimeDelta time) { | 161 void MediaPipelineImpl::StartPlayingFrom(base::TimeDelta time) { |
162 CMALOG(kLogControl) << __FUNCTION__ << " t0=" << time.InMilliseconds(); | 162 CMALOG(kLogControl) << __FUNCTION__ << " t0=" << time.InMilliseconds(); |
163 DCHECK(thread_checker_.CalledOnValidThread()); | 163 DCHECK(thread_checker_.CalledOnValidThread()); |
164 DCHECK(has_audio_ || has_video_); | 164 DCHECK(has_audio_ || has_video_); |
165 DCHECK(!pending_flush_callbacks_); | 165 DCHECK(!pending_flush_callbacks_); |
166 | 166 |
167 // Reset the start of the timeline. | 167 // Reset the start of the timeline. |
168 DCHECK_EQ(clock_device_->GetState(), MediaClockDevice::kStateIdle); | 168 DCHECK_EQ(clock_device_->GetState(), MediaClockDevice::kStateIdle); |
169 clock_device_->ResetTimeline(time); | 169 clock_device_->ResetTimeline(time.InMicroseconds()); |
170 | 170 |
171 // Start the clock. If the playback rate is 0, then the clock is started | 171 // Start the clock. If the playback rate is 0, then the clock is started |
172 // but does not increase. | 172 // but does not increase. |
173 if (!clock_device_->SetState(MediaClockDevice::kStateRunning)) { | 173 if (!clock_device_->SetState(MediaClockDevice::kStateRunning)) { |
174 OnError(::media::PIPELINE_ERROR_ABORT); | 174 OnError(::media::PIPELINE_ERROR_ABORT); |
175 return; | 175 return; |
176 } | 176 } |
177 | 177 |
178 // Enable time updates. | 178 // Enable time updates. |
179 enable_time_update_ = true; | 179 enable_time_update_ = true; |
(...skipping 23 matching lines...) Expand all Loading... |
203 return; | 203 return; |
204 } | 204 } |
205 } | 205 } |
206 } | 206 } |
207 | 207 |
208 void MediaPipelineImpl::Flush(const ::media::PipelineStatusCB& status_cb) { | 208 void MediaPipelineImpl::Flush(const ::media::PipelineStatusCB& status_cb) { |
209 CMALOG(kLogControl) << __FUNCTION__; | 209 CMALOG(kLogControl) << __FUNCTION__; |
210 DCHECK(thread_checker_.CalledOnValidThread()); | 210 DCHECK(thread_checker_.CalledOnValidThread()); |
211 DCHECK(has_audio_ || has_video_); | 211 DCHECK(has_audio_ || has_video_); |
212 DCHECK(!pending_flush_callbacks_); | 212 DCHECK(!pending_flush_callbacks_); |
| 213 DCHECK(clock_device_->GetState() == MediaClockDevice::kStateUninitialized || |
| 214 clock_device_->GetState() == MediaClockDevice::kStateRunning); |
213 | 215 |
214 // No need to update media time anymore. | 216 // No need to update media time anymore. |
215 enable_time_update_ = false; | 217 enable_time_update_ = false; |
216 | 218 |
217 buffering_controller_->Reset(); | 219 buffering_controller_->Reset(); |
218 | 220 |
219 // The clock should return to idle. | 221 // The clock should return to idle. |
220 if (!clock_device_->SetState(MediaClockDevice::kStateIdle)) { | 222 if (!clock_device_->SetState(MediaClockDevice::kStateIdle)) { |
221 status_cb.Run(::media::PIPELINE_ERROR_ABORT); | 223 status_cb.Run(::media::PIPELINE_ERROR_ABORT); |
222 return; | 224 return; |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
265 audio_pipeline_->Stop(); | 267 audio_pipeline_->Stop(); |
266 if (has_video_) | 268 if (has_video_) |
267 video_pipeline_->Stop(); | 269 video_pipeline_->Stop(); |
268 } | 270 } |
269 | 271 |
270 void MediaPipelineImpl::SetPlaybackRate(double rate) { | 272 void MediaPipelineImpl::SetPlaybackRate(double rate) { |
271 CMALOG(kLogControl) << __FUNCTION__ << " rate=" << rate; | 273 CMALOG(kLogControl) << __FUNCTION__ << " rate=" << rate; |
272 DCHECK(thread_checker_.CalledOnValidThread()); | 274 DCHECK(thread_checker_.CalledOnValidThread()); |
273 target_playback_rate_ = rate; | 275 target_playback_rate_ = rate; |
274 if (!buffering_controller_ || !buffering_controller_->IsBuffering()) | 276 if (!buffering_controller_ || !buffering_controller_->IsBuffering()) |
275 media_pipeline_device_->GetMediaClockDevice()->SetRate(rate); | 277 media_pipeline_backend_->GetClock()->SetRate(rate); |
276 } | 278 } |
277 | 279 |
278 AudioPipelineImpl* MediaPipelineImpl::GetAudioPipelineImpl() const { | 280 AudioPipelineImpl* MediaPipelineImpl::GetAudioPipelineImpl() const { |
279 return audio_pipeline_.get(); | 281 return audio_pipeline_.get(); |
280 } | 282 } |
281 | 283 |
282 VideoPipelineImpl* MediaPipelineImpl::GetVideoPipelineImpl() const { | 284 VideoPipelineImpl* MediaPipelineImpl::GetVideoPipelineImpl() const { |
283 return video_pipeline_.get(); | 285 return video_pipeline_.get(); |
284 } | 286 } |
285 | 287 |
286 void MediaPipelineImpl::StateTransition( | 288 void MediaPipelineImpl::StateTransition( |
287 const ::media::PipelineStatusCB& status_cb, | 289 const ::media::PipelineStatusCB& status_cb, |
288 ::media::PipelineStatus status) { | 290 ::media::PipelineStatus status) { |
289 pending_flush_callbacks_.reset(); | 291 pending_flush_callbacks_.reset(); |
290 status_cb.Run(status); | 292 status_cb.Run(status); |
291 } | 293 } |
292 | 294 |
293 void MediaPipelineImpl::OnBufferingNotification(bool is_buffering) { | 295 void MediaPipelineImpl::OnBufferingNotification(bool is_buffering) { |
294 CMALOG(kLogControl) << __FUNCTION__ << " is_buffering=" << is_buffering; | 296 CMALOG(kLogControl) << __FUNCTION__ << " is_buffering=" << is_buffering; |
295 DCHECK(thread_checker_.CalledOnValidThread()); | 297 DCHECK(thread_checker_.CalledOnValidThread()); |
296 DCHECK(buffering_controller_); | 298 DCHECK(buffering_controller_); |
297 | 299 |
298 if (!client_.buffering_state_cb.is_null()) { | 300 if (!client_.buffering_state_cb.is_null()) { |
299 ::media::BufferingState buffering_state = is_buffering ? | 301 ::media::BufferingState buffering_state = is_buffering ? |
300 ::media::BUFFERING_HAVE_NOTHING : ::media::BUFFERING_HAVE_ENOUGH; | 302 ::media::BUFFERING_HAVE_NOTHING : ::media::BUFFERING_HAVE_ENOUGH; |
301 client_.buffering_state_cb.Run(buffering_state); | 303 client_.buffering_state_cb.Run(buffering_state); |
302 } | 304 } |
303 | 305 |
304 if (media_pipeline_device_->GetMediaClockDevice()->GetState() == | 306 if (media_pipeline_backend_->GetClock()->GetState() == |
305 MediaClockDevice::kStateUninitialized) { | 307 MediaClockDevice::kStateUninitialized) { |
306 return; | 308 return; |
307 } | 309 } |
308 | 310 |
309 if (is_buffering) { | 311 if (is_buffering) { |
310 // Do not consume data in a rebuffering phase. | 312 // Do not consume data in a rebuffering phase. |
311 media_pipeline_device_->GetMediaClockDevice()->SetRate(0.0); | 313 media_pipeline_backend_->GetClock()->SetRate(0.0); |
312 } else { | 314 } else { |
313 media_pipeline_device_->GetMediaClockDevice()->SetRate( | 315 media_pipeline_backend_->GetClock()->SetRate(target_playback_rate_); |
314 target_playback_rate_); | |
315 } | 316 } |
316 } | 317 } |
317 | 318 |
318 void MediaPipelineImpl::UpdateMediaTime() { | 319 void MediaPipelineImpl::UpdateMediaTime() { |
319 pending_time_update_task_ = false; | 320 pending_time_update_task_ = false; |
320 if (!enable_time_update_) | 321 if (!enable_time_update_) |
321 return; | 322 return; |
322 | 323 |
323 if (statistics_rolling_counter_ == 0) { | 324 if (statistics_rolling_counter_ == 0) { |
324 audio_pipeline_->UpdateStatistics(); | 325 audio_pipeline_->UpdateStatistics(); |
325 video_pipeline_->UpdateStatistics(); | 326 video_pipeline_->UpdateStatistics(); |
326 } | 327 } |
327 statistics_rolling_counter_ = | 328 statistics_rolling_counter_ = |
328 (statistics_rolling_counter_ + 1) % kStatisticsUpdatePeriod; | 329 (statistics_rolling_counter_ + 1) % kStatisticsUpdatePeriod; |
329 | 330 |
330 base::TimeDelta media_time(clock_device_->GetTime()); | 331 base::TimeDelta media_time = |
| 332 base::TimeDelta::FromMicroseconds(clock_device_->GetTimeMicroseconds()); |
331 if (media_time == ::media::kNoTimestamp()) { | 333 if (media_time == ::media::kNoTimestamp()) { |
332 pending_time_update_task_ = true; | 334 pending_time_update_task_ = true; |
333 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | 335 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
334 FROM_HERE, base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_), | 336 FROM_HERE, base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_), |
335 kTimeUpdateInterval); | 337 kTimeUpdateInterval); |
336 return; | 338 return; |
337 } | 339 } |
338 base::TimeTicks stc = base::TimeTicks::Now(); | 340 base::TimeTicks stc = base::TimeTicks::Now(); |
339 | 341 |
340 base::TimeDelta max_rendering_time = media_time; | 342 base::TimeDelta max_rendering_time = media_time; |
(...skipping 25 matching lines...) Expand all Loading... |
366 | 368 |
367 void MediaPipelineImpl::OnError(::media::PipelineStatus error) { | 369 void MediaPipelineImpl::OnError(::media::PipelineStatus error) { |
368 DCHECK(thread_checker_.CalledOnValidThread()); | 370 DCHECK(thread_checker_.CalledOnValidThread()); |
369 DCHECK_NE(error, ::media::PIPELINE_OK) << "PIPELINE_OK is not an error!"; | 371 DCHECK_NE(error, ::media::PIPELINE_OK) << "PIPELINE_OK is not an error!"; |
370 if (!client_.error_cb.is_null()) | 372 if (!client_.error_cb.is_null()) |
371 client_.error_cb.Run(error); | 373 client_.error_cb.Run(error); |
372 } | 374 } |
373 | 375 |
374 } // namespace media | 376 } // namespace media |
375 } // namespace chromecast | 377 } // namespace chromecast |
OLD | NEW |