1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_sink_sv_impl.h"
17 #include <vector>
18 #include "media_log.h"
19 #include "media_errors.h"
20
21 namespace {
22 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioSinkSvImpl"};
23 const std::string DEFAULT_CAPS = "audio/x-raw, format = (string) S16LE, layout = (string) interleaved";
24 }
25
26 namespace OHOS {
27 namespace Media {
AudioSinkSvImpl()28 AudioSinkSvImpl::AudioSinkSvImpl()
29 : audioRenderer_(nullptr)
30 {
31 }
32
~AudioSinkSvImpl()33 AudioSinkSvImpl::~AudioSinkSvImpl()
34 {
35 if (audioRenderer_ != nullptr) {
36 (void)audioRenderer_->Release();
37 audioRenderer_ = nullptr;
38 }
39 }
40
GetCaps()41 GstCaps *AudioSinkSvImpl::GetCaps()
42 {
43 GstCaps *caps = gst_caps_from_string(DEFAULT_CAPS.c_str());
44 CHECK_AND_RETURN_RET_LOG(caps != nullptr, nullptr, "caps is null");
45 InitChannelRange(caps);
46 InitRateRange(caps);
47 return caps;
48 }
49
InitChannelRange(GstCaps * caps) const50 void AudioSinkSvImpl::InitChannelRange(GstCaps *caps) const
51 {
52 CHECK_AND_RETURN_LOG(caps != nullptr, "caps is null");
53 std::vector<AudioStandard::AudioChannel> supportedChannelsList = AudioStandard::
54 AudioRenderer::GetSupportedChannels();
55 GValue list = { 0, };
56 (void)g_value_init(&list, GST_TYPE_LIST);
57 for (auto channel : supportedChannelsList) {
58 GValue value = { 0, };
59 (void)g_value_init(&value, G_TYPE_INT);
60 g_value_set_int(&value, channel);
61 gst_value_list_append_value(&list, &value);
62 g_value_unset(&value);
63 }
64 gst_caps_set_value(caps, "channels", &list);
65 g_value_unset(&list);
66 }
67
InitRateRange(GstCaps * caps) const68 void AudioSinkSvImpl::InitRateRange(GstCaps *caps) const
69 {
70 CHECK_AND_RETURN_LOG(caps != nullptr, "caps is null");
71 std::vector<AudioStandard::AudioSamplingRate> supportedSampleList = AudioStandard::
72 AudioRenderer::GetSupportedSamplingRates();
73 GValue list = { 0, };
74 (void)g_value_init(&list, GST_TYPE_LIST);
75 for (auto rate : supportedSampleList) {
76 GValue value = { 0, };
77 (void)g_value_init(&value, G_TYPE_INT);
78 g_value_set_int(&value, rate);
79 gst_value_list_append_value(&list, &value);
80 g_value_unset(&value);
81 }
82 gst_caps_set_value(caps, "rate", &list);
83 g_value_unset(&list);
84 }
85
SetVolume(float volume)86 int32_t AudioSinkSvImpl::SetVolume(float volume)
87 {
88 MEDIA_LOGD("audioRenderer SetVolume(%{public}lf) In", volume);
89 CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION, "audioRenderer_ is nullptr");
90 int32_t ret = audioRenderer_->SetVolume(volume);
91 CHECK_AND_RETURN_RET_LOG(ret == AudioStandard::SUCCESS, MSERR_UNKNOWN, "audio server setvolume failed!");
92 MEDIA_LOGD("audioRenderer SetVolume(%{public}lf) Out", volume);
93 return MSERR_OK;
94 }
95
SetParameter(int32_t & param)96 int32_t AudioSinkSvImpl::SetParameter(int32_t ¶m)
97 {
98 int32_t contentType = (static_cast<uint32_t>(param) & 0x0000FFFF);
99 int32_t streamUsage = static_cast<uint32_t>(param) >> AudioStandard::RENDERER_STREAM_USAGE_SHIFT;
100
101 CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION, "audioRenderer_ is nullptr");
102
103 AudioStandard::AudioRendererDesc audioRendererDesc;
104 audioRendererDesc.contentType = static_cast<AudioStandard::ContentType>(contentType);
105 audioRendererDesc.streamUsage = static_cast<AudioStandard::StreamUsage>(streamUsage);
106
107 int32_t ret = audioRenderer_->SetAudioRendererDesc(audioRendererDesc);
108 CHECK_AND_RETURN_RET_LOG(ret == AudioStandard::SUCCESS, MSERR_UNKNOWN, "audio server SetParameter failed!");
109
110 return MSERR_OK;
111 }
112
GetVolume(float & volume)113 int32_t AudioSinkSvImpl::GetVolume(float &volume)
114 {
115 MEDIA_LOGD("GetVolume");
116 CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION, "audioRenderer_ is nullptr");
117 volume = audioRenderer_->GetVolume();
118 return MSERR_OK;
119 }
120
GetMaxVolume(float & volume)121 int32_t AudioSinkSvImpl::GetMaxVolume(float &volume)
122 {
123 MEDIA_LOGD("GetMaxVolume");
124 volume = 1.0; // audioRenderer maxVolume
125 return MSERR_OK;
126 }
127
GetMinVolume(float & volume)128 int32_t AudioSinkSvImpl::GetMinVolume(float &volume)
129 {
130 MEDIA_LOGD("GetMinVolume");
131 volume = 0.0; // audioRenderer minVolume
132 return MSERR_OK;
133 }
134
Prepare()135 int32_t AudioSinkSvImpl::Prepare()
136 {
137 MEDIA_LOGD("audioRenderer Prepare In");
138 audioRenderer_ = AudioStandard::AudioRenderer::Create(AudioStandard::AudioStreamType::STREAM_MUSIC);
139 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
140 MEDIA_LOGD("audioRenderer Prepare Out");
141 return MSERR_OK;
142 }
143
Start()144 int32_t AudioSinkSvImpl::Start()
145 {
146 MEDIA_LOGD("audioRenderer Start In");
147 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
148 (void)audioRenderer_->Start();
149 MEDIA_LOGD("audioRenderer Start Out");
150 return MSERR_OK;
151 }
152
Stop()153 int32_t AudioSinkSvImpl::Stop()
154 {
155 MEDIA_LOGD("audioRenderer Stop In");
156 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
157 (void)audioRenderer_->Stop();
158 MEDIA_LOGD("audioRenderer Stop Out");
159 return MSERR_OK;
160 }
161
Pause()162 int32_t AudioSinkSvImpl::Pause()
163 {
164 MEDIA_LOGD("audioRenderer Pause In");
165 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
166 CHECK_AND_RETURN_RET(audioRenderer_->Pause() == true, MSERR_UNKNOWN);
167 MEDIA_LOGD("audioRenderer Pause Out");
168 return MSERR_OK;
169 }
170
Drain()171 int32_t AudioSinkSvImpl::Drain()
172 {
173 MEDIA_LOGD("Drain");
174 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
175 CHECK_AND_RETURN_RET(audioRenderer_->Drain() == true, MSERR_UNKNOWN);
176 return MSERR_OK;
177 }
178
Flush()179 int32_t AudioSinkSvImpl::Flush()
180 {
181 MEDIA_LOGD("Flush");
182 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
183 CHECK_AND_RETURN_RET(audioRenderer_->Flush() == true, MSERR_UNKNOWN);
184 return MSERR_OK;
185 }
186
Release()187 int32_t AudioSinkSvImpl::Release()
188 {
189 MEDIA_LOGD("audioRenderer Release In");
190 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
191 (void)audioRenderer_->Release();
192 audioRenderer_ = nullptr;
193 MEDIA_LOGD("audioRenderer Release Out");
194 return MSERR_OK;
195 }
196
SetParameters(uint32_t bitsPerSample,uint32_t channels,uint32_t sampleRate)197 int32_t AudioSinkSvImpl::SetParameters(uint32_t bitsPerSample, uint32_t channels, uint32_t sampleRate)
198 {
199 (void)bitsPerSample;
200 MEDIA_LOGD("SetParameters in, channels:%{public}d, sampleRate:%{public}d", channels, sampleRate);
201 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
202
203 AudioStandard::AudioRendererParams params;
204 std::vector<AudioStandard::AudioSamplingRate> supportedSampleList = AudioStandard::
205 AudioRenderer::GetSupportedSamplingRates();
206 CHECK_AND_RETURN_RET(supportedSampleList.size() > 0, MSERR_UNKNOWN);
207 bool isValidSampleRate = false;
208 for (auto iter = supportedSampleList.cbegin(); iter != supportedSampleList.end(); ++iter) {
209 CHECK_AND_RETURN_RET(static_cast<int32_t>(*iter) > 0, MSERR_UNKNOWN);
210 uint32_t supportedSampleRate = static_cast<uint32_t>(*iter);
211 if (sampleRate <= supportedSampleRate) {
212 params.sampleRate = *iter;
213 isValidSampleRate = true;
214 break;
215 }
216 }
217 CHECK_AND_RETURN_RET(isValidSampleRate == true, MSERR_UNSUPPORT_AUD_SAMPLE_RATE);
218
219 std::vector<AudioStandard::AudioChannel> supportedChannelsList = AudioStandard::
220 AudioRenderer::GetSupportedChannels();
221 CHECK_AND_RETURN_RET(supportedChannelsList.size() > 0, MSERR_UNKNOWN);
222 bool isValidChannels = false;
223 for (auto iter = supportedChannelsList.cbegin(); iter != supportedChannelsList.end(); ++iter) {
224 CHECK_AND_RETURN_RET(static_cast<int32_t>(*iter) > 0, MSERR_UNKNOWN);
225 uint32_t supportedChannels = static_cast<uint32_t>(*iter);
226 if (channels == supportedChannels) {
227 params.channelCount = *iter;
228 isValidChannels = true;
229 break;
230 }
231 }
232 CHECK_AND_RETURN_RET(isValidChannels == true, MSERR_UNSUPPORT_AUD_CHANNEL_NUM);
233
234 params.sampleFormat = AudioStandard::SAMPLE_S16LE;
235 params.encodingType = AudioStandard::ENCODING_PCM;
236 MEDIA_LOGD("SetParameters out, channels:%{public}d, sampleRate:%{public}d", params.channelCount, params.sampleRate);
237 MEDIA_LOGD("audioRenderer SetParams In");
238 CHECK_AND_RETURN_RET(audioRenderer_->SetParams(params) == AudioStandard::SUCCESS, MSERR_UNKNOWN);
239 MEDIA_LOGD("audioRenderer SetParams Out");
240 return MSERR_OK;
241 }
242
GetParameters(uint32_t & bitsPerSample,uint32_t & channels,uint32_t & sampleRate)243 int32_t AudioSinkSvImpl::GetParameters(uint32_t &bitsPerSample, uint32_t &channels, uint32_t &sampleRate)
244 {
245 MEDIA_LOGD("GetParameters");
246 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
247 AudioStandard::AudioRendererParams params;
248 CHECK_AND_RETURN_RET(audioRenderer_->GetParams(params) == AudioStandard::SUCCESS, MSERR_UNKNOWN);
249 channels = params.channelCount;
250 sampleRate = params.sampleRate;
251 return MSERR_OK;
252 }
253
GetMinimumBufferSize(uint32_t & bufferSize)254 int32_t AudioSinkSvImpl::GetMinimumBufferSize(uint32_t &bufferSize)
255 {
256 MEDIA_LOGD("GetMinimumBufferSize");
257 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
258 size_t size = 0;
259 CHECK_AND_RETURN_RET(audioRenderer_->GetBufferSize(size) == AudioStandard::SUCCESS, MSERR_UNKNOWN);
260 CHECK_AND_RETURN_RET(size > 0, MSERR_UNKNOWN);
261 bufferSize = static_cast<uint32_t>(size);
262 return MSERR_OK;
263 }
264
GetMinimumFrameCount(uint32_t & frameCount)265 int32_t AudioSinkSvImpl::GetMinimumFrameCount(uint32_t &frameCount)
266 {
267 MEDIA_LOGD("GetMinimumFrameCount");
268 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
269 uint32_t count = 0;
270 CHECK_AND_RETURN_RET(audioRenderer_->GetFrameCount(count) == AudioStandard::SUCCESS, MSERR_UNKNOWN);
271 CHECK_AND_RETURN_RET(count > 0, MSERR_UNKNOWN);
272 frameCount = count;
273 return MSERR_OK;
274 }
275
Writeable() const276 bool AudioSinkSvImpl::Writeable() const
277 {
278 return audioRenderer_->GetStatus() == AudioStandard::RENDERER_RUNNING;
279 }
280
Write(uint8_t * buffer,size_t size)281 int32_t AudioSinkSvImpl::Write(uint8_t *buffer, size_t size)
282 {
283 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
284 size_t bytesWritten = 0;
285 int32_t bytesSingle = 0;
286 while (bytesWritten < size) {
287 bytesSingle = audioRenderer_->Write(buffer + bytesWritten, size - bytesWritten);
288 CHECK_AND_RETURN_RET(bytesSingle > 0, MSERR_UNKNOWN);
289 bytesWritten += static_cast<size_t>(bytesSingle);
290 CHECK_AND_RETURN_RET(bytesWritten >= static_cast<size_t>(bytesSingle), MSERR_UNKNOWN);
291 }
292 return MSERR_OK;
293 }
294
GetAudioTime(uint64_t & time)295 int32_t AudioSinkSvImpl::GetAudioTime(uint64_t &time)
296 {
297 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
298 AudioStandard::Timestamp timeStamp;
299 bool ret = audioRenderer_->GetAudioTime(timeStamp, AudioStandard::Timestamp::Timestampbase::MONOTONIC);
300 CHECK_AND_RETURN_RET(ret == true, MSERR_UNKNOWN);
301 time = static_cast<uint64_t>(timeStamp.time.tv_nsec);
302 return MSERR_OK;
303 }
304
GetLatency(uint64_t & latency) const305 int32_t AudioSinkSvImpl::GetLatency(uint64_t &latency) const
306 {
307 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_INVALID_OPERATION);
308 CHECK_AND_RETURN_RET(audioRenderer_->GetLatency(latency) == AudioStandard::SUCCESS, MSERR_UNKNOWN);
309 return MSERR_OK;
310 }
311 } // namespace Media
312 } // namespace OHOS
313