OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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 "webkit/glue/media/buffered_data_source.h" | 5 #include "webkit/glue/media/buffered_data_source.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "media/base/filter_host.h" | 8 #include "media/base/filter_host.h" |
9 #include "media/base/media_log.h" | 9 #include "media/base/media_log.h" |
10 #include "net/base/net_errors.h" | 10 #include "net/base/net_errors.h" |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
54 read_position_(0), | 54 read_position_(0), |
55 read_size_(0), | 55 read_size_(0), |
56 read_buffer_(NULL), | 56 read_buffer_(NULL), |
57 intermediate_read_buffer_(new uint8[kInitialReadBufferSize]), | 57 intermediate_read_buffer_(new uint8[kInitialReadBufferSize]), |
58 intermediate_read_buffer_size_(kInitialReadBufferSize), | 58 intermediate_read_buffer_size_(kInitialReadBufferSize), |
59 render_loop_(render_loop), | 59 render_loop_(render_loop), |
60 stop_signal_received_(false), | 60 stop_signal_received_(false), |
61 stopped_on_render_loop_(false), | 61 stopped_on_render_loop_(false), |
62 media_is_paused_(true), | 62 media_is_paused_(true), |
63 media_has_played_(false), | 63 media_has_played_(false), |
64 preload_(media::METADATA), | 64 preload_(media::AUTO), |
65 using_range_request_(true), | 65 using_range_request_(true), |
66 cache_miss_retries_left_(kNumCacheMissRetries), | 66 cache_miss_retries_left_(kNumCacheMissRetries), |
| 67 bitrate_(0), |
| 68 playback_rate_(0.0), |
67 media_log_(media_log) { | 69 media_log_(media_log) { |
68 } | 70 } |
69 | 71 |
70 BufferedDataSource::~BufferedDataSource() {} | 72 BufferedDataSource::~BufferedDataSource() {} |
71 | 73 |
72 // A factory method to create BufferedResourceLoader using the read parameters. | 74 // A factory method to create BufferedResourceLoader using the read parameters. |
73 // This method can be overrided to inject mock BufferedResourceLoader object | 75 // This method can be overrided to inject mock BufferedResourceLoader object |
74 // for testing purpose. | 76 // for testing purpose. |
75 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader( | 77 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader( |
76 int64 first_byte_position, int64 last_byte_position) { | 78 int64 first_byte_position, int64 last_byte_position) { |
77 DCHECK(MessageLoop::current() == render_loop_); | 79 DCHECK(MessageLoop::current() == render_loop_); |
78 | 80 |
79 return new BufferedResourceLoader(url_, | 81 return new BufferedResourceLoader(url_, |
80 first_byte_position, | 82 first_byte_position, |
81 last_byte_position, | 83 last_byte_position, |
| 84 ChooseDeferStrategy(), |
| 85 bitrate_, |
| 86 playback_rate_, |
82 media_log_); | 87 media_log_); |
83 } | 88 } |
84 | 89 |
85 void BufferedDataSource::set_host(media::FilterHost* host) { | 90 void BufferedDataSource::set_host(media::FilterHost* host) { |
86 DataSource::set_host(host); | 91 DataSource::set_host(host); |
87 | 92 |
88 if (loader_.get()) { | 93 if (loader_.get()) { |
89 base::AutoLock auto_lock(lock_); | 94 base::AutoLock auto_lock(lock_); |
90 UpdateHostState_Locked(); | 95 UpdateHostState_Locked(); |
91 } | 96 } |
(...skipping 205 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
297 return; | 302 return; |
298 | 303 |
299 { | 304 { |
300 // If there's no outstanding read then return early. | 305 // If there's no outstanding read then return early. |
301 base::AutoLock auto_lock(lock_); | 306 base::AutoLock auto_lock(lock_); |
302 if (read_callback_.is_null()) | 307 if (read_callback_.is_null()) |
303 return; | 308 return; |
304 } | 309 } |
305 | 310 |
306 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); | 311 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); |
307 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); | |
308 loader_->UpdateDeferStrategy(strategy); | |
309 loader_->Start( | 312 loader_->Start( |
310 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), | 313 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), |
311 base::Bind(&BufferedDataSource::NetworkEventCallback, this), | 314 base::Bind(&BufferedDataSource::NetworkEventCallback, this), |
312 frame_); | 315 frame_); |
313 } | 316 } |
314 | 317 |
315 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) { | 318 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) { |
316 DCHECK(MessageLoop::current() == render_loop_); | 319 DCHECK(MessageLoop::current() == render_loop_); |
317 DCHECK(loader_.get()); | 320 DCHECK(loader_.get()); |
318 | 321 |
| 322 playback_rate_ = playback_rate; |
319 loader_->SetPlaybackRate(playback_rate); | 323 loader_->SetPlaybackRate(playback_rate); |
320 | 324 |
321 bool previously_paused = media_is_paused_; | 325 bool previously_paused = media_is_paused_; |
322 media_is_paused_ = (playback_rate == 0.0); | 326 media_is_paused_ = (playback_rate == 0.0); |
323 | 327 |
324 if (!media_has_played_ && previously_paused && !media_is_paused_) | 328 if (!media_has_played_ && previously_paused && !media_is_paused_) |
325 media_has_played_ = true; | 329 media_has_played_ = true; |
326 | 330 |
327 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); | 331 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); |
328 loader_->UpdateDeferStrategy(strategy); | 332 loader_->UpdateDeferStrategy(strategy); |
329 } | 333 } |
330 | 334 |
331 void BufferedDataSource::SetPreloadTask(media::Preload preload) { | 335 void BufferedDataSource::SetPreloadTask(media::Preload preload) { |
332 DCHECK(MessageLoop::current() == render_loop_); | 336 DCHECK(MessageLoop::current() == render_loop_); |
333 preload_ = preload; | 337 preload_ = preload; |
334 } | 338 } |
335 | 339 |
336 void BufferedDataSource::SetBitrateTask(int bitrate) { | 340 void BufferedDataSource::SetBitrateTask(int bitrate) { |
337 DCHECK(MessageLoop::current() == render_loop_); | 341 DCHECK(MessageLoop::current() == render_loop_); |
338 DCHECK(loader_.get()); | 342 DCHECK(loader_.get()); |
| 343 |
| 344 bitrate_ = bitrate; |
339 loader_->SetBitrate(bitrate); | 345 loader_->SetBitrate(bitrate); |
340 } | 346 } |
341 | 347 |
342 BufferedResourceLoader::DeferStrategy | 348 BufferedResourceLoader::DeferStrategy |
343 BufferedDataSource::ChooseDeferStrategy() { | 349 BufferedDataSource::ChooseDeferStrategy() { |
344 DCHECK(MessageLoop::current() == render_loop_); | 350 DCHECK(MessageLoop::current() == render_loop_); |
345 // If the user indicates preload=metadata, then just load exactly | 351 // If the page indicated preload=metadata, then load exactly what is needed |
346 // what is needed for starting the pipeline and prerolling frames. | 352 // needed for starting playback. |
347 if (preload_ == media::METADATA && !media_has_played_) | 353 if (!media_has_played_ && preload_ == media::METADATA) |
348 return BufferedResourceLoader::kReadThenDefer; | 354 return BufferedResourceLoader::kReadThenDefer; |
349 | 355 |
350 // In general, we want to try to buffer the entire video when the video | 356 // If the playback has started (at which point the preload value is ignored) |
351 // is paused. But we don't want to do this if the video hasn't played yet | 357 // and we're paused, then try to load as much as possible. |
352 // and preload!=auto. | 358 if (media_has_played_ && media_is_paused_) |
353 if (media_is_paused_ && | |
354 (preload_ == media::AUTO || media_has_played_)) { | |
355 return BufferedResourceLoader::kNeverDefer; | 359 return BufferedResourceLoader::kNeverDefer; |
356 } | |
357 | 360 |
358 // When the video is playing, regardless of preload state, we buffer up | 361 // If media is currently playing or the page indicated preload=auto, |
359 // to a hard limit and enable/disable deferring when the buffer is | 362 // use threshold strategy to enable/disable deferring when the buffer |
360 // depleted/full. | 363 // is full/depleted. |
361 return BufferedResourceLoader::kThresholdDefer; | 364 return BufferedResourceLoader::kThresholdDefer; |
362 } | 365 } |
363 | 366 |
364 // This method is the place where actual read happens, |loader_| must be valid | 367 // This method is the place where actual read happens, |loader_| must be valid |
365 // prior to make this method call. | 368 // prior to make this method call. |
366 void BufferedDataSource::ReadInternal() { | 369 void BufferedDataSource::ReadInternal() { |
367 DCHECK(MessageLoop::current() == render_loop_); | 370 DCHECK(MessageLoop::current() == render_loop_); |
368 DCHECK(loader_); | 371 DCHECK(loader_); |
369 | 372 |
370 // First we prepare the intermediate read buffer for BufferedResourceLoader | 373 // First we prepare the intermediate read buffer for BufferedResourceLoader |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
411 | 414 |
412 ///////////////////////////////////////////////////////////////////////////// | 415 ///////////////////////////////////////////////////////////////////////////// |
413 // BufferedResourceLoader callback methods. | 416 // BufferedResourceLoader callback methods. |
414 void BufferedDataSource::HttpInitialStartCallback(int error) { | 417 void BufferedDataSource::HttpInitialStartCallback(int error) { |
415 DCHECK(MessageLoop::current() == render_loop_); | 418 DCHECK(MessageLoop::current() == render_loop_); |
416 DCHECK(loader_.get()); | 419 DCHECK(loader_.get()); |
417 | 420 |
418 int64 instance_size = loader_->instance_size(); | 421 int64 instance_size = loader_->instance_size(); |
419 bool success = error == net::OK; | 422 bool success = error == net::OK; |
420 | 423 |
421 | |
422 bool initialize_cb_is_null = false; | 424 bool initialize_cb_is_null = false; |
423 { | 425 { |
424 base::AutoLock auto_lock(lock_); | 426 base::AutoLock auto_lock(lock_); |
425 initialize_cb_is_null = initialize_cb_.is_null(); | 427 initialize_cb_is_null = initialize_cb_.is_null(); |
426 } | 428 } |
427 if (initialize_cb_is_null) { | 429 if (initialize_cb_is_null) { |
428 loader_->Stop(); | 430 loader_->Stop(); |
429 return; | 431 return; |
430 } | 432 } |
431 | 433 |
(...skipping 229 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
661 | 663 |
662 if (streaming_) { | 664 if (streaming_) { |
663 filter_host->SetStreaming(true); | 665 filter_host->SetStreaming(true); |
664 } else { | 666 } else { |
665 filter_host->SetTotalBytes(total_bytes_); | 667 filter_host->SetTotalBytes(total_bytes_); |
666 filter_host->SetBufferedBytes(buffered_bytes_); | 668 filter_host->SetBufferedBytes(buffered_bytes_); |
667 } | 669 } |
668 } | 670 } |
669 | 671 |
670 } // namespace webkit_glue | 672 } // namespace webkit_glue |
OLD | NEW |