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 136 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
303 return; | 311 return; |
304 | 312 |
305 { | 313 { |
306 // If there's no outstanding read then return early. | 314 // If there's no outstanding read then return early. |
307 base::AutoLock auto_lock(lock_); | 315 base::AutoLock auto_lock(lock_); |
308 if (!read_callback_.get()) | 316 if (!read_callback_.get()) |
309 return; | 317 return; |
310 } | 318 } |
311 | 319 |
312 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); | 320 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); |
313 loader_->SetAllowDefer(!media_is_paused_); | 321 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); |
322 loader_->UpdateDeferStrategy(strategy); | |
314 loader_->Start( | 323 loader_->Start( |
315 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), | 324 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), |
316 NewCallback(this, &BufferedDataSource::NetworkEventCallback), | 325 NewCallback(this, &BufferedDataSource::NetworkEventCallback), |
317 frame_); | 326 frame_); |
318 } | 327 } |
319 | 328 |
320 void BufferedDataSource::WatchDogTask() { | 329 void BufferedDataSource::WatchDogTask() { |
321 DCHECK(MessageLoop::current() == render_loop_); | 330 DCHECK(MessageLoop::current() == render_loop_); |
322 if (stopped_on_render_loop_) | 331 if (stopped_on_render_loop_) |
323 return; | 332 return; |
(...skipping 15 matching lines...) Expand all Loading... | |
339 if (read_attempts_ >= kReadTrials) | 348 if (read_attempts_ >= kReadTrials) |
340 return; | 349 return; |
341 | 350 |
342 ++read_attempts_; | 351 ++read_attempts_; |
343 read_submitted_time_ = base::Time::Now(); | 352 read_submitted_time_ = base::Time::Now(); |
344 | 353 |
345 // Stops the current loader and creates a new resource loader and | 354 // Stops the current loader and creates a new resource loader and |
346 // retry the request. | 355 // retry the request. |
347 loader_->Stop(); | 356 loader_->Stop(); |
348 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); | 357 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); |
349 loader_->SetAllowDefer(!media_is_paused_); | 358 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); |
359 loader_->UpdateDeferStrategy(strategy); | |
350 loader_->Start( | 360 loader_->Start( |
351 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), | 361 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), |
352 NewCallback(this, &BufferedDataSource::NetworkEventCallback), | 362 NewCallback(this, &BufferedDataSource::NetworkEventCallback), |
353 frame_); | 363 frame_); |
354 } | 364 } |
355 | 365 |
356 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) { | 366 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) { |
357 DCHECK(MessageLoop::current() == render_loop_); | 367 DCHECK(MessageLoop::current() == render_loop_); |
358 DCHECK(loader_.get()); | 368 DCHECK(loader_.get()); |
359 | 369 |
360 bool previously_paused = media_is_paused_; | 370 bool previously_paused = media_is_paused_; |
361 media_is_paused_ = (playback_rate == 0.0); | 371 media_is_paused_ = (playback_rate == 0.0); |
362 | 372 |
363 // Disallow deferring data when we are pausing, allow deferring data | 373 if (!media_has_played_ && previously_paused && !media_is_paused_) |
364 // when we resume playing. | 374 media_has_played_ = true; |
365 if (previously_paused && !media_is_paused_) { | 375 |
366 loader_->SetAllowDefer(true); | 376 BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy(); |
367 } else if (!previously_paused && media_is_paused_) { | 377 loader_->UpdateDeferStrategy(strategy); |
368 loader_->SetAllowDefer(false); | 378 } |
379 | |
380 void BufferedDataSource::SetPreloadTask(media::Preload preload) { | |
381 DCHECK(MessageLoop::current() == render_loop_); | |
382 preload_ = preload; | |
383 } | |
384 | |
385 BufferedResourceLoader::DeferStrategy | |
386 BufferedDataSource::ChooseDeferStrategy() { | |
scherkus (not reviewing)
2011/04/05 06:22:45
nit: method name should be completely un-indented
vrk (LEFT CHROMIUM)
2011/04/05 16:17:41
Done.
| |
387 // If the user indicates preload=metadata, then just load exactly | |
388 // what is needed for starting the pipeline and prerolling frames. | |
389 if (preload_ == media::METADATA && !media_has_played_) | |
390 return BufferedResourceLoader::kReadThenDefer; | |
391 | |
392 // In general, we want to try to buffer the entire video when the video | |
393 // is paused. But we don't want to do this if the video hasn't played yet | |
394 // and preload!=auto. | |
395 if (media_is_paused_ && | |
396 (preload_ == media::AUTO || media_has_played_)) { | |
397 return BufferedResourceLoader::kNeverDefer; | |
369 } | 398 } |
399 | |
400 // When the video is playing, regardless of preload state, we buffer up | |
401 // to a hard limit and enable/disable deferring when the buffer is | |
402 // depleted/full. | |
403 return BufferedResourceLoader::kThresholdDefer; | |
370 } | 404 } |
371 | 405 |
372 // This method is the place where actual read happens, |loader_| must be valid | 406 // This method is the place where actual read happens, |loader_| must be valid |
373 // prior to make this method call. | 407 // prior to make this method call. |
374 void BufferedDataSource::ReadInternal() { | 408 void BufferedDataSource::ReadInternal() { |
375 DCHECK(MessageLoop::current() == render_loop_); | 409 DCHECK(MessageLoop::current() == render_loop_); |
376 DCHECK(loader_); | 410 DCHECK(loader_); |
377 | 411 |
378 // First we prepare the intermediate read buffer for BufferedResourceLoader | 412 // First we prepare the intermediate read buffer for BufferedResourceLoader |
379 // to write to. | 413 // to write to. |
(...skipping 269 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
649 | 683 |
650 if (streaming_) { | 684 if (streaming_) { |
651 filter_host->SetStreaming(true); | 685 filter_host->SetStreaming(true); |
652 } else { | 686 } else { |
653 filter_host->SetTotalBytes(total_bytes_); | 687 filter_host->SetTotalBytes(total_bytes_); |
654 filter_host->SetBufferedBytes(buffered_bytes_); | 688 filter_host->SetBufferedBytes(buffered_bytes_); |
655 } | 689 } |
656 } | 690 } |
657 | 691 |
658 } // namespace webkit_glue | 692 } // namespace webkit_glue |
OLD | NEW |