OLD | NEW |
---|---|
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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/backend/media_pipeline_backend_wrapper.h" | 5 #include "chromecast/media/cma/backend/media_pipeline_backend_wrapper.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "base/memory/ptr_util.h" | |
8 #include "chromecast/media/cma/backend/media_pipeline_backend_manager.h" | 9 #include "chromecast/media/cma/backend/media_pipeline_backend_manager.h" |
10 #include "chromecast/public/cast_media_shlib.h" | |
9 | 11 |
10 namespace chromecast { | 12 namespace chromecast { |
11 namespace media { | 13 namespace media { |
12 | 14 |
13 using DecoderType = MediaPipelineBackendManager::DecoderType; | 15 using DecoderType = MediaPipelineBackendManager::DecoderType; |
14 | 16 |
15 MediaPipelineBackendWrapper::MediaPipelineBackendWrapper( | 17 MediaPipelineBackendWrapper::MediaPipelineBackendWrapper( |
16 std::unique_ptr<MediaPipelineBackend> backend, | 18 const media::MediaPipelineDeviceParams& params, |
17 int stream_type, | |
18 float stream_type_volume, | |
19 MediaPipelineBackendManager* backend_manager) | 19 MediaPipelineBackendManager* backend_manager) |
20 : backend_(std::move(backend)), | 20 : backend_(base::WrapUnique( |
21 stream_type_(stream_type), | 21 media::CastMediaShlib::CreateMediaPipelineBackend(params))), |
22 audio_decoder_wrapper_(nullptr), | 22 backend_manager_(backend_manager), |
23 stream_type_volume_(stream_type_volume), | 23 sfx_backend_(params.audio_type == |
24 is_initialized_(false), | 24 media::MediaPipelineDeviceParams::kAudioStreamSoundEffects), |
25 have_audio_decoder_(false), | |
25 have_video_decoder_(false), | 26 have_video_decoder_(false), |
26 backend_manager_(backend_manager) { | 27 playing_(false) { |
27 DCHECK(backend_); | 28 DCHECK(backend_); |
29 DCHECK(backend_manager_); | |
28 } | 30 } |
29 | 31 |
30 MediaPipelineBackendWrapper::~MediaPipelineBackendWrapper() { | 32 MediaPipelineBackendWrapper::~MediaPipelineBackendWrapper() { |
31 backend_manager_->OnMediaPipelineBackendDestroyed(this); | 33 if (have_audio_decoder_) |
32 | 34 backend_manager_->DecrementDecoderCount( |
33 if (audio_decoder_wrapper_) | 35 sfx_backend_ ? DecoderType::SFX_DECODER : DecoderType::AUDIO_DECODER); |
halliwell
2017/02/24 21:37:21
nit: {} for multiline
kmackay
2017/02/24 23:53:29
Done.
| |
34 backend_manager_->DecrementDecoderCount(DecoderType::AUDIO_DECODER); | |
35 if (have_video_decoder_) | 36 if (have_video_decoder_) |
36 backend_manager_->DecrementDecoderCount(DecoderType::VIDEO_DECODER); | 37 backend_manager_->DecrementDecoderCount(DecoderType::VIDEO_DECODER); |
38 | |
39 if (playing_) { | |
40 LOG(WARNING) << "Destroying media backend while still in 'playing' state"; | |
41 if (have_audio_decoder_ && !sfx_backend_) { | |
42 backend_manager_->UpdatePlayingAudioCount(-1); | |
43 } | |
44 } | |
37 } | 45 } |
38 | 46 |
39 MediaPipelineBackend::AudioDecoder* | 47 MediaPipelineBackend::AudioDecoder* |
40 MediaPipelineBackendWrapper::CreateAudioDecoder() { | 48 MediaPipelineBackendWrapper::CreateAudioDecoder() { |
41 DCHECK(!is_initialized_); | 49 DCHECK(!have_audio_decoder_); |
42 if (audio_decoder_wrapper_) | 50 |
51 if (!backend_manager_->IncrementDecoderCount( | |
52 sfx_backend_ ? DecoderType::SFX_DECODER : DecoderType::AUDIO_DECODER)) | |
43 return nullptr; | 53 return nullptr; |
54 have_audio_decoder_ = true; | |
44 | 55 |
45 if (!backend_manager_->IncrementDecoderCount(DecoderType::AUDIO_DECODER)) | 56 return backend_->CreateAudioDecoder(); |
46 return nullptr; | |
47 | |
48 audio_decoder_wrapper_.reset( | |
49 new AudioDecoderWrapper(backend_->CreateAudioDecoder())); | |
50 return audio_decoder_wrapper_.get(); | |
51 } | 57 } |
52 | 58 |
53 MediaPipelineBackend::VideoDecoder* | 59 MediaPipelineBackend::VideoDecoder* |
54 MediaPipelineBackendWrapper::CreateVideoDecoder() { | 60 MediaPipelineBackendWrapper::CreateVideoDecoder() { |
55 DCHECK(!is_initialized_); | |
56 DCHECK(!have_video_decoder_); | 61 DCHECK(!have_video_decoder_); |
57 | 62 |
58 if (!backend_manager_->IncrementDecoderCount(DecoderType::VIDEO_DECODER)) | 63 if (!backend_manager_->IncrementDecoderCount(DecoderType::VIDEO_DECODER)) |
59 return nullptr; | 64 return nullptr; |
60 have_video_decoder_ = true; | 65 have_video_decoder_ = true; |
61 | 66 |
62 return backend_->CreateVideoDecoder(); | 67 return backend_->CreateVideoDecoder(); |
63 } | 68 } |
64 | 69 |
65 bool MediaPipelineBackendWrapper::Initialize() { | 70 bool MediaPipelineBackendWrapper::Initialize() { |
66 DCHECK(!is_initialized_); | 71 return backend_->Initialize(); |
67 is_initialized_ = backend_->Initialize(); | |
68 if (is_initialized_ && audio_decoder_wrapper_) | |
69 audio_decoder_wrapper_->SetStreamTypeVolume(stream_type_volume_); | |
70 | |
71 return is_initialized_; | |
72 } | 72 } |
73 | 73 |
74 bool MediaPipelineBackendWrapper::Start(int64_t start_pts) { | 74 bool MediaPipelineBackendWrapper::Start(int64_t start_pts) { |
75 return backend_->Start(start_pts); | 75 if (!backend_->Start(start_pts)) { |
76 return false; | |
77 } | |
78 SetPlaying(true); | |
79 return true; | |
76 } | 80 } |
77 | 81 |
78 void MediaPipelineBackendWrapper::Stop() { | 82 void MediaPipelineBackendWrapper::Stop() { |
79 backend_->Stop(); | 83 backend_->Stop(); |
84 SetPlaying(false); | |
80 } | 85 } |
81 | 86 |
82 bool MediaPipelineBackendWrapper::Pause() { | 87 bool MediaPipelineBackendWrapper::Pause() { |
83 return backend_->Pause(); | 88 if (!backend_->Pause()) { |
89 return false; | |
90 } | |
91 SetPlaying(true); | |
halliwell
2017/02/24 21:37:21
um, false? :)
kmackay
2017/02/24 23:53:29
Done.
| |
92 return true; | |
84 } | 93 } |
85 | 94 |
86 bool MediaPipelineBackendWrapper::Resume() { | 95 bool MediaPipelineBackendWrapper::Resume() { |
87 return backend_->Resume(); | 96 if (!backend_->Resume()) { |
97 return false; | |
98 } | |
99 SetPlaying(false); | |
halliwell
2017/02/24 21:37:21
true? :)
kmackay
2017/02/24 23:53:29
Done.
| |
100 return true; | |
88 } | 101 } |
89 | 102 |
90 int64_t MediaPipelineBackendWrapper::GetCurrentPts() { | 103 int64_t MediaPipelineBackendWrapper::GetCurrentPts() { |
91 return backend_->GetCurrentPts(); | 104 return backend_->GetCurrentPts(); |
92 } | 105 } |
93 | 106 |
94 bool MediaPipelineBackendWrapper::SetPlaybackRate(float rate) { | 107 bool MediaPipelineBackendWrapper::SetPlaybackRate(float rate) { |
95 return backend_->SetPlaybackRate(rate); | 108 return backend_->SetPlaybackRate(rate); |
96 } | 109 } |
97 | 110 |
98 int MediaPipelineBackendWrapper::GetStreamType() const { | 111 void MediaPipelineBackendWrapper::SetPlaying(bool playing) { |
99 return stream_type_; | 112 if (playing == playing_) { |
100 } | 113 return; |
101 | 114 } |
102 void MediaPipelineBackendWrapper::SetStreamTypeVolume( | 115 playing_ = playing; |
103 float stream_type_volume) { | 116 if (have_audio_decoder_ && !sfx_backend_) { |
104 stream_type_volume_ = stream_type_volume; | 117 backend_manager_->UpdatePlayingAudioCount(playing_ ? 1 : -1); |
105 if (is_initialized_ && audio_decoder_wrapper_) | 118 } |
106 audio_decoder_wrapper_->SetStreamTypeVolume(stream_type_volume_); | |
107 } | 119 } |
108 | 120 |
109 } // namespace media | 121 } // namespace media |
110 } // namespace chromecast | 122 } // namespace chromecast |
OLD | NEW |