OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "media/base/pipeline.h" | 5 #include "media/base/pipeline.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/callback.h" | 10 #include "base/callback.h" |
11 #include "base/callback_helpers.h" | 11 #include "base/callback_helpers.h" |
12 #include "base/compiler_specific.h" | 12 #include "base/compiler_specific.h" |
13 #include "base/message_loop/message_loop.h" | 13 #include "base/message_loop/message_loop.h" |
14 #include "base/metrics/histogram.h" | 14 #include "base/metrics/histogram.h" |
15 #include "base/stl_util.h" | 15 #include "base/stl_util.h" |
16 #include "base/strings/string_number_conversions.h" | 16 #include "base/strings/string_number_conversions.h" |
17 #include "base/strings/string_util.h" | 17 #include "base/strings/string_util.h" |
18 #include "base/synchronization/condition_variable.h" | 18 #include "base/synchronization/condition_variable.h" |
19 #include "media/base/audio_decoder.h" | 19 #include "media/base/audio_decoder.h" |
20 #include "media/base/audio_renderer.h" | 20 #include "media/base/audio_renderer.h" |
21 #include "media/base/clock.h" | 21 #include "media/base/clock.h" |
22 #include "media/base/filter_collection.h" | 22 #include "media/base/filter_collection.h" |
23 #include "media/base/media_log.h" | 23 #include "media/base/media_log.h" |
24 #include "media/base/text_renderer.h" | |
24 #include "media/base/video_decoder.h" | 25 #include "media/base/video_decoder.h" |
25 #include "media/base/video_decoder_config.h" | 26 #include "media/base/video_decoder_config.h" |
26 #include "media/base/video_renderer.h" | 27 #include "media/base/video_renderer.h" |
27 | 28 |
28 using base::TimeDelta; | 29 using base::TimeDelta; |
29 | 30 |
30 namespace media { | 31 namespace media { |
31 | 32 |
32 Pipeline::Pipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop, | 33 Pipeline::Pipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop, |
33 MediaLog* media_log) | 34 MediaLog* media_log) |
34 : message_loop_(message_loop), | 35 : message_loop_(message_loop), |
35 media_log_(media_log), | 36 media_log_(media_log), |
36 running_(false), | 37 running_(false), |
37 did_loading_progress_(false), | 38 did_loading_progress_(false), |
38 total_bytes_(0), | 39 total_bytes_(0), |
39 natural_size_(0, 0), | 40 natural_size_(0, 0), |
40 volume_(1.0f), | 41 volume_(1.0f), |
41 playback_rate_(0.0f), | 42 playback_rate_(0.0f), |
42 clock_(new Clock(&default_tick_clock_)), | 43 clock_(new Clock(&default_tick_clock_)), |
43 waiting_for_clock_update_(false), | 44 waiting_for_clock_update_(false), |
44 status_(PIPELINE_OK), | 45 status_(PIPELINE_OK), |
45 has_audio_(false), | 46 has_audio_(false), |
46 has_video_(false), | 47 has_video_(false), |
47 state_(kCreated), | 48 state_(kCreated), |
48 audio_ended_(false), | 49 audio_ended_(false), |
49 video_ended_(false), | 50 video_ended_(false), |
51 text_ended_(false), | |
50 audio_disabled_(false), | 52 audio_disabled_(false), |
51 demuxer_(NULL), | 53 demuxer_(NULL), |
52 creation_time_(default_tick_clock_.NowTicks()) { | 54 creation_time_(default_tick_clock_.NowTicks()) { |
53 media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated)); | 55 media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated)); |
54 media_log_->AddEvent( | 56 media_log_->AddEvent( |
55 media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED)); | 57 media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED)); |
56 } | 58 } |
57 | 59 |
58 Pipeline::~Pipeline() { | 60 Pipeline::~Pipeline() { |
59 DCHECK(thread_checker_.CalledOnValidThread()) | 61 DCHECK(thread_checker_.CalledOnValidThread()) |
(...skipping 226 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
286 break; | 288 break; |
287 } | 289 } |
288 NOTREACHED() << "State has no transition: " << state_; | 290 NOTREACHED() << "State has no transition: " << state_; |
289 return state_; | 291 return state_; |
290 } | 292 } |
291 | 293 |
292 void Pipeline::OnDemuxerError(PipelineStatus error) { | 294 void Pipeline::OnDemuxerError(PipelineStatus error) { |
293 SetError(error); | 295 SetError(error); |
294 } | 296 } |
295 | 297 |
298 void Pipeline::AddTextStream(DemuxerStream* text_stream, | |
299 TextKind kind, | |
300 const std::string& label, | |
301 const std::string& language) { | |
302 DCHECK(message_loop_->BelongsToCurrentThread()); | |
303 text_renderer_->AddTextStream(text_stream, kind, label, language); | |
304 } | |
305 | |
296 void Pipeline::SetError(PipelineStatus error) { | 306 void Pipeline::SetError(PipelineStatus error) { |
297 DCHECK(IsRunning()); | 307 DCHECK(IsRunning()); |
298 DCHECK_NE(PIPELINE_OK, error); | 308 DCHECK_NE(PIPELINE_OK, error); |
299 VLOG(1) << "Media pipeline error: " << error; | 309 VLOG(1) << "Media pipeline error: " << error; |
300 | 310 |
301 message_loop_->PostTask(FROM_HERE, base::Bind( | 311 message_loop_->PostTask(FROM_HERE, base::Bind( |
302 &Pipeline::ErrorChangedTask, base::Unretained(this), error)); | 312 &Pipeline::ErrorChangedTask, base::Unretained(this), error)); |
303 | 313 |
304 media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error)); | 314 media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error)); |
305 } | 315 } |
(...skipping 224 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
530 | 540 |
531 // Pause. | 541 // Pause. |
532 if (audio_renderer_) { | 542 if (audio_renderer_) { |
533 bound_fns.Push(base::Bind( | 543 bound_fns.Push(base::Bind( |
534 &AudioRenderer::Pause, base::Unretained(audio_renderer_.get()))); | 544 &AudioRenderer::Pause, base::Unretained(audio_renderer_.get()))); |
535 } | 545 } |
536 if (video_renderer_) { | 546 if (video_renderer_) { |
537 bound_fns.Push(base::Bind( | 547 bound_fns.Push(base::Bind( |
538 &VideoRenderer::Pause, base::Unretained(video_renderer_.get()))); | 548 &VideoRenderer::Pause, base::Unretained(video_renderer_.get()))); |
539 } | 549 } |
550 if (text_renderer_) { | |
551 bound_fns.Push(base::Bind( | |
552 &TextRenderer::Pause, base::Unretained(text_renderer_.get()))); | |
553 } | |
540 | 554 |
541 // Flush. | 555 // Flush. |
542 if (audio_renderer_) { | 556 if (audio_renderer_) { |
543 bound_fns.Push(base::Bind( | 557 bound_fns.Push(base::Bind( |
544 &AudioRenderer::Flush, base::Unretained(audio_renderer_.get()))); | 558 &AudioRenderer::Flush, base::Unretained(audio_renderer_.get()))); |
545 } | 559 } |
546 if (video_renderer_) { | 560 if (video_renderer_) { |
547 bound_fns.Push(base::Bind( | 561 bound_fns.Push(base::Bind( |
548 &VideoRenderer::Flush, base::Unretained(video_renderer_.get()))); | 562 &VideoRenderer::Flush, base::Unretained(video_renderer_.get()))); |
549 } | 563 } |
564 if (text_renderer_) { | |
565 bound_fns.Push(base::Bind( | |
566 &TextRenderer::Flush, base::Unretained(text_renderer_.get()))); | |
567 } | |
550 | 568 |
551 // Seek demuxer. | 569 // Seek demuxer. |
552 bound_fns.Push(base::Bind( | 570 bound_fns.Push(base::Bind( |
553 &Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp)); | 571 &Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp)); |
554 | 572 |
555 // Preroll renderers. | 573 // Preroll renderers. |
556 if (audio_renderer_) { | 574 if (audio_renderer_) { |
557 bound_fns.Push(base::Bind( | 575 bound_fns.Push(base::Bind( |
558 &AudioRenderer::Preroll, base::Unretained(audio_renderer_.get()), | 576 &AudioRenderer::Preroll, base::Unretained(audio_renderer_.get()), |
559 seek_timestamp)); | 577 seek_timestamp)); |
(...skipping 19 matching lines...) Expand all Loading... | |
579 if (audio_renderer_) { | 597 if (audio_renderer_) { |
580 bound_fns.Push(base::Bind( | 598 bound_fns.Push(base::Bind( |
581 &AudioRenderer::Play, base::Unretained(audio_renderer_.get()))); | 599 &AudioRenderer::Play, base::Unretained(audio_renderer_.get()))); |
582 } | 600 } |
583 | 601 |
584 if (video_renderer_) { | 602 if (video_renderer_) { |
585 bound_fns.Push(base::Bind( | 603 bound_fns.Push(base::Bind( |
586 &VideoRenderer::Play, base::Unretained(video_renderer_.get()))); | 604 &VideoRenderer::Play, base::Unretained(video_renderer_.get()))); |
587 } | 605 } |
588 | 606 |
607 if (text_renderer_) { | |
608 bound_fns.Push(base::Bind( | |
609 &TextRenderer::Play, base::Unretained(text_renderer_.get()))); | |
610 } | |
611 | |
589 pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb); | 612 pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb); |
590 } | 613 } |
591 | 614 |
592 void Pipeline::DoStop(const PipelineStatusCB& done_cb) { | 615 void Pipeline::DoStop(const PipelineStatusCB& done_cb) { |
593 DCHECK(message_loop_->BelongsToCurrentThread()); | 616 DCHECK(message_loop_->BelongsToCurrentThread()); |
594 DCHECK(!pending_callbacks_.get()); | 617 DCHECK(!pending_callbacks_.get()); |
595 SerialRunner::Queue bound_fns; | 618 SerialRunner::Queue bound_fns; |
596 | 619 |
597 if (demuxer_) { | 620 if (demuxer_) { |
598 bound_fns.Push(base::Bind( | 621 bound_fns.Push(base::Bind( |
599 &Demuxer::Stop, base::Unretained(demuxer_))); | 622 &Demuxer::Stop, base::Unretained(demuxer_))); |
600 } | 623 } |
601 | 624 |
602 if (audio_renderer_) { | 625 if (audio_renderer_) { |
603 bound_fns.Push(base::Bind( | 626 bound_fns.Push(base::Bind( |
604 &AudioRenderer::Stop, base::Unretained(audio_renderer_.get()))); | 627 &AudioRenderer::Stop, base::Unretained(audio_renderer_.get()))); |
605 } | 628 } |
606 | 629 |
607 if (video_renderer_) { | 630 if (video_renderer_) { |
608 bound_fns.Push(base::Bind( | 631 bound_fns.Push(base::Bind( |
609 &VideoRenderer::Stop, base::Unretained(video_renderer_.get()))); | 632 &VideoRenderer::Stop, base::Unretained(video_renderer_.get()))); |
610 } | 633 } |
611 | 634 |
635 if (text_renderer_) { | |
636 bound_fns.Push(base::Bind( | |
637 &TextRenderer::Stop, base::Unretained(text_renderer_.get()))); | |
638 } | |
639 | |
612 pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb); | 640 pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb); |
613 } | 641 } |
614 | 642 |
615 void Pipeline::OnStopCompleted(PipelineStatus status) { | 643 void Pipeline::OnStopCompleted(PipelineStatus status) { |
616 DCHECK(message_loop_->BelongsToCurrentThread()); | 644 DCHECK(message_loop_->BelongsToCurrentThread()); |
617 DCHECK_EQ(state_, kStopping); | 645 DCHECK_EQ(state_, kStopping); |
618 { | 646 { |
619 base::AutoLock l(lock_); | 647 base::AutoLock l(lock_); |
620 running_ = false; | 648 running_ = false; |
621 } | 649 } |
622 | 650 |
623 SetState(kStopped); | 651 SetState(kStopped); |
624 pending_callbacks_.reset(); | 652 pending_callbacks_.reset(); |
625 filter_collection_.reset(); | 653 filter_collection_.reset(); |
626 audio_renderer_.reset(); | 654 audio_renderer_.reset(); |
627 video_renderer_.reset(); | 655 video_renderer_.reset(); |
656 text_renderer_.reset(); | |
628 demuxer_ = NULL; | 657 demuxer_ = NULL; |
629 | 658 |
630 // If we stop during initialization/seeking we want to run |seek_cb_| | 659 // If we stop during initialization/seeking we want to run |seek_cb_| |
631 // followed by |stop_cb_| so we don't leave outstanding callbacks around. | 660 // followed by |stop_cb_| so we don't leave outstanding callbacks around. |
632 if (!seek_cb_.is_null()) { | 661 if (!seek_cb_.is_null()) { |
633 base::ResetAndReturn(&seek_cb_).Run(status_); | 662 base::ResetAndReturn(&seek_cb_).Run(status_); |
634 error_cb_.Reset(); | 663 error_cb_.Reset(); |
635 } | 664 } |
636 if (!stop_cb_.is_null()) { | 665 if (!stop_cb_.is_null()) { |
637 error_cb_.Reset(); | 666 error_cb_.Reset(); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
678 media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::AUDIO_ENDED)); | 707 media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::AUDIO_ENDED)); |
679 } | 708 } |
680 | 709 |
681 void Pipeline::OnVideoRendererEnded() { | 710 void Pipeline::OnVideoRendererEnded() { |
682 // Force post to process ended messages after current execution frame. | 711 // Force post to process ended messages after current execution frame. |
683 message_loop_->PostTask(FROM_HERE, base::Bind( | 712 message_loop_->PostTask(FROM_HERE, base::Bind( |
684 &Pipeline::DoVideoRendererEnded, base::Unretained(this))); | 713 &Pipeline::DoVideoRendererEnded, base::Unretained(this))); |
685 media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::VIDEO_ENDED)); | 714 media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::VIDEO_ENDED)); |
686 } | 715 } |
687 | 716 |
717 void Pipeline::OnTextRendererEnded() { | |
718 // Force post to process ended messages after current execution frame. | |
719 message_loop_->PostTask(FROM_HERE, base::Bind( | |
720 &Pipeline::DoTextRendererEnded, base::Unretained(this))); | |
721 media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::TEXT_ENDED)); | |
722 } | |
723 | |
688 // Called from any thread. | 724 // Called from any thread. |
689 void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) { | 725 void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) { |
690 base::AutoLock auto_lock(lock_); | 726 base::AutoLock auto_lock(lock_); |
691 statistics_.audio_bytes_decoded += stats.audio_bytes_decoded; | 727 statistics_.audio_bytes_decoded += stats.audio_bytes_decoded; |
692 statistics_.video_bytes_decoded += stats.video_bytes_decoded; | 728 statistics_.video_bytes_decoded += stats.video_bytes_decoded; |
693 statistics_.video_frames_decoded += stats.video_frames_decoded; | 729 statistics_.video_frames_decoded += stats.video_frames_decoded; |
694 statistics_.video_frames_dropped += stats.video_frames_dropped; | 730 statistics_.video_frames_dropped += stats.video_frames_dropped; |
695 } | 731 } |
696 | 732 |
697 void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection, | 733 void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection, |
698 const base::Closure& ended_cb, | 734 const base::Closure& ended_cb, |
699 const PipelineStatusCB& error_cb, | 735 const PipelineStatusCB& error_cb, |
700 const PipelineStatusCB& seek_cb, | 736 const PipelineStatusCB& seek_cb, |
701 const BufferingStateCB& buffering_state_cb, | 737 const BufferingStateCB& buffering_state_cb, |
702 const base::Closure& duration_change_cb) { | 738 const base::Closure& duration_change_cb) { |
703 DCHECK(message_loop_->BelongsToCurrentThread()); | 739 DCHECK(message_loop_->BelongsToCurrentThread()); |
704 CHECK_EQ(kCreated, state_) | 740 CHECK_EQ(kCreated, state_) |
705 << "Media pipeline cannot be started more than once"; | 741 << "Media pipeline cannot be started more than once"; |
706 | 742 |
707 filter_collection_ = filter_collection.Pass(); | 743 filter_collection_ = filter_collection.Pass(); |
708 ended_cb_ = ended_cb; | 744 ended_cb_ = ended_cb; |
709 error_cb_ = error_cb; | 745 error_cb_ = error_cb; |
710 seek_cb_ = seek_cb; | 746 seek_cb_ = seek_cb; |
711 buffering_state_cb_ = buffering_state_cb; | 747 buffering_state_cb_ = buffering_state_cb; |
712 duration_change_cb_ = duration_change_cb; | 748 duration_change_cb_ = duration_change_cb; |
713 | 749 |
750 text_renderer_ = filter_collection_->GetTextRenderer(); | |
751 | |
752 if (text_renderer_) | |
acolwell GONE FROM CHROMIUM
2013/10/08 15:45:24
nit: Add {} since this is a multi-line statement.
Matthew Heaney (Chromium)
2013/10/13 05:30:17
Done.
| |
753 text_renderer_->Initialize( | |
754 base::Bind(&Pipeline::OnTextRendererEnded, base::Unretained(this))); | |
755 | |
714 StateTransitionTask(PIPELINE_OK); | 756 StateTransitionTask(PIPELINE_OK); |
715 } | 757 } |
716 | 758 |
717 void Pipeline::StopTask(const base::Closure& stop_cb) { | 759 void Pipeline::StopTask(const base::Closure& stop_cb) { |
718 DCHECK(message_loop_->BelongsToCurrentThread()); | 760 DCHECK(message_loop_->BelongsToCurrentThread()); |
719 DCHECK(stop_cb_.is_null()); | 761 DCHECK(stop_cb_.is_null()); |
720 | 762 |
721 if (state_ == kStopped) { | 763 if (state_ == kStopped) { |
722 stop_cb.Run(); | 764 stop_cb.Run(); |
723 return; | 765 return; |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
795 return; | 837 return; |
796 } | 838 } |
797 | 839 |
798 DCHECK(seek_cb_.is_null()); | 840 DCHECK(seek_cb_.is_null()); |
799 | 841 |
800 SetState(kSeeking); | 842 SetState(kSeeking); |
801 base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime()); | 843 base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime()); |
802 seek_cb_ = seek_cb; | 844 seek_cb_ = seek_cb; |
803 audio_ended_ = false; | 845 audio_ended_ = false; |
804 video_ended_ = false; | 846 video_ended_ = false; |
847 text_ended_ = false; | |
805 | 848 |
806 // Kick off seeking! | 849 // Kick off seeking! |
807 { | 850 { |
808 base::AutoLock auto_lock(lock_); | 851 base::AutoLock auto_lock(lock_); |
809 if (clock_->IsPlaying()) | 852 if (clock_->IsPlaying()) |
810 clock_->Pause(); | 853 clock_->Pause(); |
811 clock_->SetTime(seek_timestamp, seek_timestamp); | 854 clock_->SetTime(seek_timestamp, seek_timestamp); |
812 } | 855 } |
813 DoSeek(seek_timestamp, base::Bind( | 856 DoSeek(seek_timestamp, base::Bind( |
814 &Pipeline::OnStateTransition, base::Unretained(this))); | 857 &Pipeline::OnStateTransition, base::Unretained(this))); |
(...skipping 23 matching lines...) Expand all Loading... | |
838 | 881 |
839 if (state_ != kStarted) | 882 if (state_ != kStarted) |
840 return; | 883 return; |
841 | 884 |
842 DCHECK(!video_ended_); | 885 DCHECK(!video_ended_); |
843 video_ended_ = true; | 886 video_ended_ = true; |
844 | 887 |
845 RunEndedCallbackIfNeeded(); | 888 RunEndedCallbackIfNeeded(); |
846 } | 889 } |
847 | 890 |
891 void Pipeline::DoTextRendererEnded() { | |
892 DCHECK(message_loop_->BelongsToCurrentThread()); | |
893 | |
894 if (state_ != kStarted) | |
895 return; | |
896 | |
897 DCHECK(!text_ended_); | |
898 text_ended_ = true; | |
899 | |
900 RunEndedCallbackIfNeeded(); | |
901 } | |
902 | |
848 void Pipeline::RunEndedCallbackIfNeeded() { | 903 void Pipeline::RunEndedCallbackIfNeeded() { |
849 DCHECK(message_loop_->BelongsToCurrentThread()); | 904 DCHECK(message_loop_->BelongsToCurrentThread()); |
850 | 905 |
851 if (audio_renderer_ && !audio_ended_ && !audio_disabled_) | 906 if (audio_renderer_ && !audio_ended_ && !audio_disabled_) |
852 return; | 907 return; |
853 | 908 |
854 if (video_renderer_ && !video_ended_) | 909 if (video_renderer_ && !video_ended_) |
855 return; | 910 return; |
856 | 911 |
912 if (text_renderer_ && text_renderer_->HasTracks() && !text_ended_) | |
913 return; | |
914 | |
857 { | 915 { |
858 base::AutoLock auto_lock(lock_); | 916 base::AutoLock auto_lock(lock_); |
859 clock_->EndOfStream(); | 917 clock_->EndOfStream(); |
860 } | 918 } |
861 | 919 |
862 DCHECK_EQ(status_, PIPELINE_OK); | 920 DCHECK_EQ(status_, PIPELINE_OK); |
863 ended_cb_.Run(); | 921 ended_cb_.Run(); |
864 } | 922 } |
865 | 923 |
866 void Pipeline::AudioDisabledTask() { | 924 void Pipeline::AudioDisabledTask() { |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
942 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() { | 1000 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() { |
943 lock_.AssertAcquired(); | 1001 lock_.AssertAcquired(); |
944 if (!waiting_for_clock_update_) | 1002 if (!waiting_for_clock_update_) |
945 return; | 1003 return; |
946 | 1004 |
947 waiting_for_clock_update_ = false; | 1005 waiting_for_clock_update_ = false; |
948 clock_->Play(); | 1006 clock_->Play(); |
949 } | 1007 } |
950 | 1008 |
951 } // namespace media | 1009 } // namespace media |
OLD | NEW |