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 "media/base/filter_host.h" | 7 #include "media/base/filter_host.h" |
8 #include "net/base/net_errors.h" | 8 #include "net/base/net_errors.h" |
9 #include "webkit/glue/media/web_data_source_factory.h" | 9 #include "webkit/glue/media/web_data_source_factory.h" |
10 #include "webkit/glue/webkit_glue.h" | 10 #include "webkit/glue/webkit_glue.h" |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
57 read_position_(0), | 57 read_position_(0), |
58 read_size_(0), | 58 read_size_(0), |
59 read_buffer_(NULL), | 59 read_buffer_(NULL), |
60 read_attempts_(0), | 60 read_attempts_(0), |
61 intermediate_read_buffer_(new uint8[kInitialReadBufferSize]), | 61 intermediate_read_buffer_(new uint8[kInitialReadBufferSize]), |
62 intermediate_read_buffer_size_(kInitialReadBufferSize), | 62 intermediate_read_buffer_size_(kInitialReadBufferSize), |
63 render_loop_(render_loop), | 63 render_loop_(render_loop), |
64 stop_signal_received_(false), | 64 stop_signal_received_(false), |
65 stopped_on_render_loop_(false), | 65 stopped_on_render_loop_(false), |
66 media_is_paused_(true), | 66 media_is_paused_(true), |
67 media_has_played_(false), | |
68 preload_(media::METADATA), | |
67 using_range_request_(true) { | 69 using_range_request_(true) { |
68 } | 70 } |
69 | 71 |
70 BufferedDataSource::~BufferedDataSource() { | 72 BufferedDataSource::~BufferedDataSource() { |
71 } | 73 } |
72 | 74 |
73 // A factory method to create BufferedResourceLoader using the read parameters. | 75 // A factory method to create BufferedResourceLoader using the read parameters. |
74 // This method can be overrided to inject mock BufferedResourceLoader object | 76 // This method can be overrided to inject mock BufferedResourceLoader object |
75 // for testing purpose. | 77 // for testing purpose. |
76 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader( | 78 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader( |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
147 render_loop_->PostTask(FROM_HERE, | 149 render_loop_->PostTask(FROM_HERE, |
148 NewRunnableMethod(this, &BufferedDataSource::CleanupTask)); | 150 NewRunnableMethod(this, &BufferedDataSource::CleanupTask)); |
149 } | 151 } |
150 | 152 |
151 void BufferedDataSource::SetPlaybackRate(float playback_rate) { | 153 void BufferedDataSource::SetPlaybackRate(float playback_rate) { |
152 render_loop_->PostTask(FROM_HERE, | 154 render_loop_->PostTask(FROM_HERE, |
153 NewRunnableMethod(this, &BufferedDataSource::SetPlaybackRateTask, | 155 NewRunnableMethod(this, &BufferedDataSource::SetPlaybackRateTask, |
154 playback_rate)); | 156 playback_rate)); |
155 } | 157 } |
156 | 158 |
159 void BufferedDataSource::SetPreload(media::Preload preload) { | |
160 render_loop_->PostTask(FROM_HERE, | |
161 NewRunnableMethod(this, &BufferedDataSource::SetPreloadTask, | |
162 preload)); | |
163 } | |
164 | |
157 ///////////////////////////////////////////////////////////////////////////// | 165 ///////////////////////////////////////////////////////////////////////////// |
158 // media::DataSource implementation. | 166 // media::DataSource implementation. |
159 void BufferedDataSource::Read(int64 position, size_t size, uint8* data, | 167 void BufferedDataSource::Read(int64 position, size_t size, uint8* data, |
160 media::DataSource::ReadCallback* read_callback) { | 168 media::DataSource::ReadCallback* read_callback) { |
161 DCHECK(read_callback); | 169 DCHECK(read_callback); |
162 | 170 |
163 { | 171 { |
164 base::AutoLock auto_lock(lock_); | 172 base::AutoLock auto_lock(lock_); |
165 DCHECK(!read_callback_.get()); | 173 DCHECK(!read_callback_.get()); |
166 | 174 |
(...skipping 142 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
309 return; | 317 return; |
310 | 318 |
311 { | 319 { |
312 // If there's no outstanding read then return early. | 320 // If there's no outstanding read then return early. |
313 base::AutoLock auto_lock(lock_); | 321 base::AutoLock auto_lock(lock_); |
314 if (!read_callback_.get()) | 322 if (!read_callback_.get()) |
315 return; | 323 return; |
316 } | 324 } |
317 | 325 |
318 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); | 326 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); |
319 loader_->SetAllowDefer(!media_is_paused_); | 327 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); |
328 loader_->UpdateDeferStrategy(strategy); | |
320 loader_->Start( | 329 loader_->Start( |
321 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), | 330 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), |
322 NewCallback(this, &BufferedDataSource::NetworkEventCallback), | 331 NewCallback(this, &BufferedDataSource::NetworkEventCallback), |
323 frame_); | 332 frame_); |
324 } | 333 } |
325 | 334 |
326 void BufferedDataSource::WatchDogTask() { | 335 void BufferedDataSource::WatchDogTask() { |
327 DCHECK(MessageLoop::current() == render_loop_); | 336 DCHECK(MessageLoop::current() == render_loop_); |
328 if (stopped_on_render_loop_) | 337 if (stopped_on_render_loop_) |
329 return; | 338 return; |
(...skipping 15 matching lines...) Expand all Loading... | |
345 if (read_attempts_ >= kReadTrials) | 354 if (read_attempts_ >= kReadTrials) |
346 return; | 355 return; |
347 | 356 |
348 ++read_attempts_; | 357 ++read_attempts_; |
349 read_submitted_time_ = base::Time::Now(); | 358 read_submitted_time_ = base::Time::Now(); |
350 | 359 |
351 // Stops the current loader and creates a new resource loader and | 360 // Stops the current loader and creates a new resource loader and |
352 // retry the request. | 361 // retry the request. |
353 loader_->Stop(); | 362 loader_->Stop(); |
354 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); | 363 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); |
355 loader_->SetAllowDefer(!media_is_paused_); | 364 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); |
365 loader_->UpdateDeferStrategy(strategy); | |
356 loader_->Start( | 366 loader_->Start( |
357 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), | 367 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), |
358 NewCallback(this, &BufferedDataSource::NetworkEventCallback), | 368 NewCallback(this, &BufferedDataSource::NetworkEventCallback), |
359 frame_); | 369 frame_); |
360 } | 370 } |
361 | 371 |
362 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) { | 372 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) { |
363 DCHECK(MessageLoop::current() == render_loop_); | 373 DCHECK(MessageLoop::current() == render_loop_); |
364 DCHECK(loader_.get()); | 374 DCHECK(loader_.get()); |
365 | 375 |
366 bool previously_paused = media_is_paused_; | 376 bool previously_paused = media_is_paused_; |
367 media_is_paused_ = (playback_rate == 0.0); | 377 media_is_paused_ = (playback_rate == 0.0); |
368 | 378 |
369 // Disallow deferring data when we are pausing, allow deferring data | 379 if (!media_has_played_ && previously_paused && !media_is_paused_) |
370 // when we resume playing. | 380 media_has_played_ = true; |
371 if (previously_paused && !media_is_paused_) { | 381 |
372 loader_->SetAllowDefer(true); | 382 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); |
373 } else if (!previously_paused && media_is_paused_) { | 383 loader_->UpdateDeferStrategy(strategy); |
374 loader_->SetAllowDefer(false); | 384 } |
385 | |
386 void BufferedDataSource::SetPreloadTask(media::Preload preload) { | |
387 DCHECK(MessageLoop::current() == render_loop_); | |
388 preload_ = preload; | |
389 } | |
390 | |
391 BufferedResourceLoader::DeferStrategy BufferedDataSource::ChooseDeferStrategy() { | |
scherkus (not reviewing)
2011/03/31 23:40:21
nit: >80 chars
drop the method name onto next lin
vrk (LEFT CHROMIUM)
2011/04/01 22:52:12
Done.
| |
392 // If the user indicates preload=metadata, then just load exactly | |
393 // what is needed for starting the pipeline and prerolling frames. | |
394 if (preload_ == media::METADATA && !media_has_played_) | |
395 return BufferedResourceLoader::kReadThenDefer; | |
396 | |
397 // In general, we want to try to buffer the entire video when the video | |
398 // is paused. But we don't want to do this if the video hasn't played yet | |
399 // and preload!=auto. | |
400 if (media_is_paused_ && | |
401 (preload_ == media::AUTO || media_has_played_)) { | |
402 return BufferedResourceLoader::kNeverDefer; | |
375 } | 403 } |
404 | |
405 // When the video is playing, regardless of preload state, we buffer up | |
406 // to a hard limit and enable/disable deferring when the buffer is | |
407 // depleted/full. | |
408 return BufferedResourceLoader::kThresholdDefer; | |
376 } | 409 } |
377 | 410 |
378 // This method is the place where actual read happens, |loader_| must be valid | 411 // This method is the place where actual read happens, |loader_| must be valid |
379 // prior to make this method call. | 412 // prior to make this method call. |
380 void BufferedDataSource::ReadInternal() { | 413 void BufferedDataSource::ReadInternal() { |
381 DCHECK(MessageLoop::current() == render_loop_); | 414 DCHECK(MessageLoop::current() == render_loop_); |
382 DCHECK(loader_); | 415 DCHECK(loader_); |
383 | 416 |
384 // First we prepare the intermediate read buffer for BufferedResourceLoader | 417 // First we prepare the intermediate read buffer for BufferedResourceLoader |
385 // to write to. | 418 // to write to. |
(...skipping 269 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
655 | 688 |
656 if (streaming_) { | 689 if (streaming_) { |
657 filter_host->SetStreaming(true); | 690 filter_host->SetStreaming(true); |
658 } else { | 691 } else { |
659 filter_host->SetTotalBytes(total_bytes_); | 692 filter_host->SetTotalBytes(total_bytes_); |
660 filter_host->SetBufferedBytes(buffered_bytes_); | 693 filter_host->SetBufferedBytes(buffered_bytes_); |
661 } | 694 } |
662 } | 695 } |
663 | 696 |
664 } // namespace webkit_glue | 697 } // namespace webkit_glue |
OLD | NEW |