Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(191)

Side by Side Diff: chromecast/media/cma/pipeline/media_pipeline_impl.cc

Issue 1257013003: Load CMA backend from shared library (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698