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 <unistd.h>
19 #include "media_log.h"
20 #include "media_errors.h"
21 #include "media_dfx.h"
22 #include "param_wrapper.h"
23 #include "player_xcollie.h"
24 #include "scope_guard.h"
25 #include "audio_effect.h"
26
27 namespace {
28 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioSinkSvImpl"};
29 const std::string DEFAULT_CAPS = "audio/x-raw, format = (string) S16LE, layout = (string) interleaved";
30 }
31
32 namespace OHOS {
33 namespace Media {
AudioRendererMediaCallback(GstBaseSink * audioSink)34 AudioRendererMediaCallback::AudioRendererMediaCallback(GstBaseSink *audioSink)
35 : audioSink_(audioSink), taskQue_("AudioCallback")
36 {
37 (void)taskQue_.Start();
38 }
39
~AudioRendererMediaCallback()40 AudioRendererMediaCallback::~AudioRendererMediaCallback()
41 {
42 (void)taskQue_.Stop();
43 }
44
SaveInterruptCallback(InterruptCbFunc interruptCb)45 void AudioRendererMediaCallback::SaveInterruptCallback(InterruptCbFunc interruptCb)
46 {
47 interruptCb_ = interruptCb;
48 }
49
SaveStateCallback(StateCbFunc stateCb)50 void AudioRendererMediaCallback::SaveStateCallback(StateCbFunc stateCb)
51 {
52 stateCb_ = stateCb;
53 }
54
AudioServiceDiedCallback(GstBaseSink * audioSink)55 AudioServiceDiedCallback::AudioServiceDiedCallback(GstBaseSink *audioSink) : audioSink_(audioSink)
56 {
57 MEDIA_LOGD("AudioServiceDiedCallback create");
58 }
59
SaveAudioPolicyServiceDiedCb(AudioDiedCbFunc diedCb)60 void AudioServiceDiedCallback::SaveAudioPolicyServiceDiedCb(AudioDiedCbFunc diedCb)
61 {
62 diedCb_ = diedCb;
63 }
64
OnAudioPolicyServiceDied()65 void AudioServiceDiedCallback::OnAudioPolicyServiceDied()
66 {
67 CHECK_AND_RETURN_LOG(diedCb_ != nullptr, "audio policy died cb is null");
68 diedCb_(audioSink_);
69 }
70
OnInterrupt(const AudioStandard::InterruptEvent & interruptEvent)71 void AudioRendererMediaCallback::OnInterrupt(const AudioStandard::InterruptEvent &interruptEvent)
72 {
73 auto task = std::make_shared<TaskHandler<void>>([this, interruptEvent] {
74 if (interruptCb_ != nullptr) {
75 interruptCb_(audioSink_, interruptEvent.eventType, interruptEvent.forceType, interruptEvent.hintType);
76 }
77 });
78 (void)taskQue_.EnqueueTask(task);
79 }
80
OnStateChange(const AudioStandard::RendererState state,const AudioStandard::StateChangeCmdType cmdType)81 void AudioRendererMediaCallback::OnStateChange(const AudioStandard::RendererState state,
82 const AudioStandard::StateChangeCmdType cmdType)
83 {
84 MEDIA_LOGD("RenderState is %{public}d, type is %{public}d",
85 static_cast<int32_t>(state), static_cast<int32_t>(cmdType));
86 if (cmdType == AudioStandard::StateChangeCmdType::CMD_FROM_SYSTEM) {
87 auto task = std::make_shared<TaskHandler<void>>([this, state] {
88 if (stateCb_ != nullptr) {
89 stateCb_(audioSink_, static_cast<guint>(state));
90 }
91 });
92 (void)taskQue_.EnqueueTask(task);
93 }
94 }
95
AudioSinkSvImpl(GstBaseSink * sink)96 AudioSinkSvImpl::AudioSinkSvImpl(GstBaseSink *sink)
97 : audioSink_(sink)
98 {
99 audioRendererMediaCallback_ = std::make_shared<AudioRendererMediaCallback>(sink);
100 audioServiceDiedCallback_ = std::make_shared<AudioServiceDiedCallback>(sink);
101 SetAudioDumpBySysParam();
102 }
103
~AudioSinkSvImpl()104 AudioSinkSvImpl::~AudioSinkSvImpl()
105 {
106 if (audioRenderer_ != nullptr) {
107 LISTENER((void)audioRenderer_->Release(); audioRenderer_ = nullptr,
108 "AudioRenderer::Release", PlayerXCollie::timerTimeout)
109 }
110 if (dumpFile_ != nullptr) {
111 (void)fclose(dumpFile_);
112 dumpFile_ = nullptr;
113 }
114 }
115
GetCaps()116 GstCaps *AudioSinkSvImpl::GetCaps()
117 {
118 GstCaps *caps = gst_caps_from_string(DEFAULT_CAPS.c_str());
119 CHECK_AND_RETURN_RET_LOG(caps != nullptr, nullptr, "caps is null");
120 InitChannelRange(caps);
121 InitRateRange(caps);
122 return caps;
123 }
124
InitChannelRange(GstCaps * caps) const125 void AudioSinkSvImpl::InitChannelRange(GstCaps *caps) const
126 {
127 CHECK_AND_RETURN_LOG(caps != nullptr, "caps is null");
128 std::vector<AudioStandard::AudioChannel> supportedChannelsList = AudioStandard::
129 AudioRenderer::GetSupportedChannels();
130 GValue list = G_VALUE_INIT;
131 (void)g_value_init(&list, GST_TYPE_LIST);
132 for (auto channel : supportedChannelsList) {
133 GValue value = G_VALUE_INIT;
134 (void)g_value_init(&value, G_TYPE_INT);
135 g_value_set_int(&value, channel);
136 gst_value_list_append_value(&list, &value);
137 g_value_unset(&value);
138 }
139 gst_caps_set_value(caps, "channels", &list);
140 g_value_unset(&list);
141 }
142
InitRateRange(GstCaps * caps) const143 void AudioSinkSvImpl::InitRateRange(GstCaps *caps) const
144 {
145 CHECK_AND_RETURN_LOG(caps != nullptr, "caps is null");
146 std::vector<AudioStandard::AudioSamplingRate> supportedSampleList = AudioStandard::
147 AudioRenderer::GetSupportedSamplingRates();
148 GValue list = G_VALUE_INIT;
149 (void)g_value_init(&list, GST_TYPE_LIST);
150 for (auto rate : supportedSampleList) {
151 GValue value = G_VALUE_INIT;
152 (void)g_value_init(&value, G_TYPE_INT);
153 g_value_set_int(&value, rate);
154 gst_value_list_append_value(&list, &value);
155 g_value_unset(&value);
156 }
157 gst_caps_set_value(caps, "rate", &list);
158 g_value_unset(&list);
159 }
160
SetMuteVolumeBySysParam()161 void AudioSinkSvImpl::SetMuteVolumeBySysParam()
162 {
163 std::string onMute;
164 int32_t res = OHOS::system::GetStringParameter("sys.media.set.mute", onMute, "");
165 if (res == 0 && !onMute.empty()) {
166 if (onMute == "TRUE") {
167 isMute_ = true;
168 (void)SetVolume(0.0);
169 MEDIA_LOGD("SetVolume as 0");
170 } else if (onMute == "FALSE") {
171 isMute_ = false;
172 (void)SetVolume(1.0);
173 MEDIA_LOGD("SetVolume as 1");
174 }
175 }
176 }
177
SetVolume(float volume)178 int32_t AudioSinkSvImpl::SetVolume(float volume)
179 {
180 MediaTrace trace("AudioSink::SetVolume");
181 MEDIA_LOGD("audioRenderer SetVolume(%{public}lf) In", volume);
182 CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED, "audioRenderer_ is nullptr");
183 volume = (isMute_ == false) ? volume : 0.0;
184 int32_t ret = -1;
185 LISTENER(ret = audioRenderer_->SetVolume(volume), "AudioRenderer::SetVolume", PlayerXCollie::timerTimeout)
186 CHECK_AND_RETURN_RET_LOG(ret == AudioStandard::SUCCESS, MSERR_AUD_RENDER_FAILED, "audio server setvolume failed!");
187 MEDIA_LOGD("audioRenderer SetVolume(%{public}lf) Out", volume);
188 return MSERR_OK;
189 }
190
SetRendererInfo(int32_t desc,int32_t rendererFlags)191 int32_t AudioSinkSvImpl::SetRendererInfo(int32_t desc, int32_t rendererFlags)
192 {
193 int32_t contentType = (static_cast<uint32_t>(desc) & 0x0000FFFF);
194 int32_t streamUsage = static_cast<uint32_t>(desc) >> AudioStandard::RENDERER_STREAM_USAGE_SHIFT;
195 rendererOptions_.rendererInfo.contentType = static_cast<AudioStandard::ContentType>(contentType);
196 rendererOptions_.rendererInfo.streamUsage = static_cast<AudioStandard::StreamUsage>(streamUsage);
197 rendererOptions_.rendererInfo.rendererFlags = rendererFlags;
198 return MSERR_OK;
199 }
200
GetVolume(float & volume)201 int32_t AudioSinkSvImpl::GetVolume(float &volume)
202 {
203 MEDIA_LOGD("GetVolume");
204 CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED, "audioRenderer_ is nullptr");
205 XcollieTimer xCollie("AudioRenderer::GetVolume", PlayerXCollie::timerTimeout);
206 volume = audioRenderer_->GetVolume();
207 return MSERR_OK;
208 }
209
GetMaxVolume(float & volume)210 int32_t AudioSinkSvImpl::GetMaxVolume(float &volume)
211 {
212 MEDIA_LOGD("GetMaxVolume");
213 volume = 1.0; // audioRenderer maxVolume
214 return MSERR_OK;
215 }
216
GetMinVolume(float & volume)217 int32_t AudioSinkSvImpl::GetMinVolume(float &volume)
218 {
219 MEDIA_LOGD("GetMinVolume");
220 volume = 0.0; // audioRenderer minVolume
221 return MSERR_OK;
222 }
223
DisableAudioEffectBySysParam() const224 bool AudioSinkSvImpl::DisableAudioEffectBySysParam() const
225 {
226 std::string cmd;
227 int32_t ret = OHOS::system::GetStringParameter("sys.media.audio.effect.disable", cmd, "");
228 if (ret == 0 && !cmd.empty()) {
229 return cmd == "TRUE" ? TRUE : FALSE;
230 }
231 return FALSE;
232 }
233
Prepare(int32_t appUid,int32_t appPid,uint32_t appTokenId)234 int32_t AudioSinkSvImpl::Prepare(int32_t appUid, int32_t appPid, uint32_t appTokenId)
235 {
236 MediaTrace trace("AudioSink::Prepare");
237 MEDIA_LOGD("audioRenderer Prepare In");
238 AudioStandard::AppInfo appInfo = {};
239 appInfo.appUid = appUid;
240 appInfo.appPid = appPid;
241 appInfo.appTokenId = appTokenId;
242 rendererOptions_.streamInfo.samplingRate = AudioStandard::SAMPLE_RATE_8000;
243 rendererOptions_.streamInfo.encoding = AudioStandard::ENCODING_PCM;
244 rendererOptions_.streamInfo.format = AudioStandard::SAMPLE_S16LE;
245 rendererOptions_.streamInfo.channels = AudioStandard::MONO;
246 LISTENER(audioRenderer_ = AudioStandard::AudioRenderer::Create(rendererOptions_, appInfo),
247 "AudioRenderer::Create", PlayerXCollie::timerTimeout)
248 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
249 SetMuteVolumeBySysParam();
250 OHOS::AudioStandard::AudioEffectMode effectMode = DisableAudioEffectBySysParam() ?
251 OHOS::AudioStandard::AudioEffectMode::EFFECT_NONE :
252 OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT;
253 audioRenderer_->SetAudioEffectMode(effectMode);
254 MEDIA_LOGD("audioRenderer Prepare Out");
255 return MSERR_OK;
256 }
257
Start()258 int32_t AudioSinkSvImpl::Start()
259 {
260 MediaTrace trace("AudioSink::Start");
261 MEDIA_LOGD("audioRenderer Start In");
262 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
263 bool ret = false;
264 LISTENER(
265 ret = audioRenderer_->Start(),
266 "AudioRenderer::Start",
267 PlayerXCollie::timerTimeout)
268 MEDIA_LOGD("audioRenderer Start Out");
269 return ret ? MSERR_OK : MSERR_INVALID_OPERATION;
270 }
271
Stop()272 int32_t AudioSinkSvImpl::Stop()
273 {
274 MediaTrace trace("AudioSink::Stop");
275 MEDIA_LOGD("audioRenderer Stop In");
276 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
277 LISTENER((void)audioRenderer_->Stop(), "AudioRenderer::Stop", PlayerXCollie::timerTimeout)
278 MEDIA_LOGD("audioRenderer Stop Out");
279 return MSERR_OK;
280 }
281
Pause()282 int32_t AudioSinkSvImpl::Pause()
283 {
284 MediaTrace trace("AudioSink::Pause");
285 MEDIA_LOGD("audioRenderer Pause In");
286 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
287 if (audioRenderer_->GetStatus() == OHOS::AudioStandard::RENDERER_RUNNING) {
288 LISTENER(
289 bool ret = audioRenderer_->Pause();
290 if (ret == false) {
291 MEDIA_LOGE("audio Renderer Pause failed!");
292 }
293 CHECK_AND_RETURN_RET(ret == true, MSERR_AUD_RENDER_FAILED),
294 "AudioRenderer::Pause",
295 PlayerXCollie::timerTimeout)
296 }
297 MEDIA_LOGD("audioRenderer Pause Out");
298 return MSERR_OK;
299 }
300
Drain()301 int32_t AudioSinkSvImpl::Drain()
302 {
303 MediaTrace trace("AudioSink::Drain");
304 MEDIA_LOGD("Drain");
305 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
306 bool ret = false;
307 LISTENER(ret = audioRenderer_->Drain(), "AudioRenderer::Drain", PlayerXCollie::timerTimeout)
308 CHECK_AND_RETURN_RET(ret == true, MSERR_AUD_RENDER_FAILED);
309 return MSERR_OK;
310 }
311
Flush()312 int32_t AudioSinkSvImpl::Flush()
313 {
314 MediaTrace trace("AudioSink::Flush");
315 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
316 OHOS::AudioStandard::RendererState state = audioRenderer_->GetStatus();
317 MEDIA_LOGD("AudioSinkSvImpl Flush in, audioRender state = %{public}d", state);
318 if (state == OHOS::AudioStandard::RENDERER_RUNNING || state == OHOS::AudioStandard::RENDERER_PAUSED ||
319 state == OHOS::AudioStandard::RENDERER_STOPPED) {
320 bool ret = false;
321 LISTENER(ret = audioRenderer_->Flush(), "AudioRenderer::Flush", PlayerXCollie::timerTimeout)
322 CHECK_AND_RETURN_RET(ret == true, MSERR_AUD_RENDER_FAILED);
323 }
324 return MSERR_OK;
325 }
326
Release()327 int32_t AudioSinkSvImpl::Release()
328 {
329 MediaTrace trace("AudioSink::Release");
330 MEDIA_LOGD("audioRenderer Release In");
331 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
332 LISTENER((void)audioRenderer_->Release(); audioRenderer_ = nullptr,
333 "AudioRenderer::Release", PlayerXCollie::timerTimeout)
334 MEDIA_LOGD("audioRenderer Release Out");
335 return MSERR_OK;
336 }
337
SetParameters(uint32_t bitsPerSample,uint32_t channels,uint32_t sampleRate)338 int32_t AudioSinkSvImpl::SetParameters(uint32_t bitsPerSample, uint32_t channels, uint32_t sampleRate)
339 {
340 MediaTrace trace("AudioSink::SetParameters");
341 (void)bitsPerSample;
342 MEDIA_LOGD("SetParameters in, channels:%{public}d, sampleRate:%{public}d", channels, sampleRate);
343 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
344
345 AudioStandard::AudioRendererParams params;
346 std::vector<AudioStandard::AudioSamplingRate> supportedSampleList = AudioStandard::
347 AudioRenderer::GetSupportedSamplingRates();
348 CHECK_AND_RETURN_RET(supportedSampleList.size() > 0, MSERR_AUD_RENDER_FAILED);
349 bool isValidSampleRate = false;
350 for (auto iter = supportedSampleList.cbegin(); iter != supportedSampleList.end(); ++iter) {
351 CHECK_AND_RETURN_RET(static_cast<int32_t>(*iter) > 0, MSERR_AUD_RENDER_FAILED);
352 uint32_t supportedSampleRate = static_cast<uint32_t>(*iter);
353 if (sampleRate <= supportedSampleRate) {
354 params.sampleRate = *iter;
355 isValidSampleRate = true;
356 break;
357 }
358 }
359 CHECK_AND_RETURN_RET(isValidSampleRate == true, MSERR_UNSUPPORT_AUD_SAMPLE_RATE);
360
361 std::vector<AudioStandard::AudioChannel> supportedChannelsList = AudioStandard::
362 AudioRenderer::GetSupportedChannels();
363 CHECK_AND_RETURN_RET(supportedChannelsList.size() > 0, MSERR_AUD_RENDER_FAILED);
364 bool isValidChannels = false;
365 for (auto iter = supportedChannelsList.cbegin(); iter != supportedChannelsList.end(); ++iter) {
366 CHECK_AND_RETURN_RET(static_cast<int32_t>(*iter) > 0, MSERR_AUD_RENDER_FAILED);
367 uint32_t supportedChannels = static_cast<uint32_t>(*iter);
368 if (channels == supportedChannels) {
369 params.channelCount = *iter;
370 isValidChannels = true;
371 break;
372 }
373 }
374 CHECK_AND_RETURN_RET(isValidChannels == true, MSERR_UNSUPPORT_AUD_CHANNEL_NUM);
375
376 params.sampleFormat = AudioStandard::SAMPLE_S16LE;
377 params.encodingType = AudioStandard::ENCODING_PCM;
378 MEDIA_LOGD("SetParameters out, channels:%{public}d, sampleRate:%{public}d", params.channelCount, params.sampleRate);
379 MEDIA_LOGD("audioRenderer SetParams In");
380 int32_t ret = -1;
381 LISTENER(ret = audioRenderer_->SetParams(params), "AudioRenderer::SetParams", PlayerXCollie::timerTimeout)
382 CHECK_AND_RETURN_RET(ret == AudioStandard::SUCCESS, MSERR_AUD_RENDER_FAILED);
383 MEDIA_LOGD("audioRenderer SetParams Out");
384 return MSERR_OK;
385 }
386
GetParameters(uint32_t & bitsPerSample,uint32_t & channels,uint32_t & sampleRate)387 int32_t AudioSinkSvImpl::GetParameters(uint32_t &bitsPerSample, uint32_t &channels, uint32_t &sampleRate)
388 {
389 (void)bitsPerSample;
390 MEDIA_LOGD("GetParameters");
391 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
392 AudioStandard::AudioRendererParams params;
393 int32_t ret = -1;
394 LISTENER(ret = audioRenderer_->GetParams(params), "AudioRenderer::GetParams", PlayerXCollie::timerTimeout)
395 CHECK_AND_RETURN_RET(ret == AudioStandard::SUCCESS, MSERR_AUD_RENDER_FAILED);
396 channels = params.channelCount;
397 sampleRate = params.sampleRate;
398 return MSERR_OK;
399 }
400
GetMinimumBufferSize(uint32_t & bufferSize)401 int32_t AudioSinkSvImpl::GetMinimumBufferSize(uint32_t &bufferSize)
402 {
403 MEDIA_LOGD("GetMinimumBufferSize");
404 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
405 size_t size = 0;
406 int32_t ret = -1;
407 LISTENER(ret = audioRenderer_->GetBufferSize(size), "AudioRenderer::GetBufferSize", PlayerXCollie::timerTimeout)
408 CHECK_AND_RETURN_RET(ret == AudioStandard::SUCCESS, MSERR_AUD_RENDER_FAILED);
409 CHECK_AND_RETURN_RET(size > 0, MSERR_AUD_RENDER_FAILED);
410 bufferSize = static_cast<uint32_t>(size);
411 return MSERR_OK;
412 }
413
GetMinimumFrameCount(uint32_t & frameCount)414 int32_t AudioSinkSvImpl::GetMinimumFrameCount(uint32_t &frameCount)
415 {
416 MEDIA_LOGD("GetMinimumFrameCount");
417 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
418 uint32_t count = 0;
419 int32_t ret = -1;
420 LISTENER(ret = audioRenderer_->GetFrameCount(count), "AudioRenderer::GetFrameCount", PlayerXCollie::timerTimeout)
421 CHECK_AND_RETURN_RET(ret == AudioStandard::SUCCESS, MSERR_AUD_RENDER_FAILED);
422 CHECK_AND_RETURN_RET(count > 0, MSERR_AUD_RENDER_FAILED);
423 frameCount = count;
424 return MSERR_OK;
425 }
426
Writeable() const427 bool AudioSinkSvImpl::Writeable() const
428 {
429 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, false);
430 int32_t ret = -1;
431 LISTENER(ret = audioRenderer_->GetStatus(), "AudioRenderer::GetStatus", PlayerXCollie::timerTimeout)
432 return ret == AudioStandard::RENDERER_RUNNING;
433 }
434
OnError(std::string errMsg)435 void AudioSinkSvImpl::OnError(std::string errMsg)
436 {
437 if (errorCb_ != nullptr) {
438 errorCb_(audioSink_, errMsg);
439 }
440 }
441
Write(uint8_t * buffer,size_t size)442 int32_t AudioSinkSvImpl::Write(uint8_t *buffer, size_t size)
443 {
444 MediaTrace trace("AudioSink::Write");
445 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
446 CHECK_AND_RETURN_RET(buffer != nullptr, MSERR_AUD_RENDER_FAILED);
447 CHECK_AND_RETURN_RET(size > 0, MSERR_AUD_RENDER_FAILED);
448
449 size_t bytesWritten = 0;
450 LISTENER(
451 while (bytesWritten < size) {
452 MediaTrace trace("AudioSink::Write:" + std::to_string(size - bytesWritten));
453 int32_t bytesSingle = audioRenderer_->Write(buffer + bytesWritten, size - bytesWritten);
454 if (bytesSingle <= 0) {
455 MEDIA_LOGE("[AudioSinkSvImpl] audioRenderer write failed, drop an audio packet!");
456 return MSERR_OK;
457 }
458 DumpAudioBuffer(buffer, bytesWritten, static_cast<size_t>(bytesSingle));
459 bytesWritten += static_cast<size_t>(bytesSingle);
460 CHECK_AND_RETURN_RET(bytesWritten >= static_cast<size_t>(bytesSingle), MSERR_AUD_RENDER_FAILED);
461 }, "AudioRenderer::Write", PlayerXCollie::timerTimeout)
462 return MSERR_OK;
463 }
464
GetAudioTime(uint64_t & time)465 int32_t AudioSinkSvImpl::GetAudioTime(uint64_t &time)
466 {
467 MediaTrace trace("AudioSink::GetAudioTime");
468 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
469 AudioStandard::Timestamp timeStamp;
470 bool ret = false;
471 LISTENER(ret = audioRenderer_->GetAudioTime(timeStamp, AudioStandard::Timestamp::Timestampbase::MONOTONIC),
472 "AudioRenderer::GetAudioTime", PlayerXCollie::timerTimeout)
473 CHECK_AND_RETURN_RET(ret == true, MSERR_AUD_RENDER_FAILED);
474 time = static_cast<uint64_t>(timeStamp.time.tv_nsec);
475 return MSERR_OK;
476 }
477
GetLatency(uint64_t & latency) const478 int32_t AudioSinkSvImpl::GetLatency(uint64_t &latency) const
479 {
480 MediaTrace trace("AudioSink::GetLatency");
481 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
482 int32_t ret = -1;
483 LISTENER(ret = audioRenderer_->GetLatency(latency), "AudioRenderer::GetLatency", PlayerXCollie::timerTimeout)
484 CHECK_AND_RETURN_RET(ret == AudioStandard::SUCCESS, MSERR_AUD_RENDER_FAILED);
485 return MSERR_OK;
486 }
487
SetAudioSinkCb(void (* interruptCb)(GstBaseSink *,guint,guint,guint),void (* stateCb)(GstBaseSink *,guint),void (* errorCb)(GstBaseSink *,const std::string &),void (* audioDiedCb)(GstBaseSink *))488 void AudioSinkSvImpl::SetAudioSinkCb(void (*interruptCb)(GstBaseSink *, guint, guint, guint),
489 void (*stateCb)(GstBaseSink *, guint),
490 void (*errorCb)(GstBaseSink *, const std::string &),
491 void (*audioDiedCb)(GstBaseSink *))
492 {
493 CHECK_AND_RETURN(audioRendererMediaCallback_ != nullptr);
494 errorCb_ = errorCb;
495 audioRendererMediaCallback_->SaveInterruptCallback(interruptCb);
496 audioRendererMediaCallback_->SaveStateCallback(stateCb);
497 XcollieTimer xCollie("AudioRenderer::SetRendererCallback", PlayerXCollie::timerTimeout);
498 CHECK_AND_RETURN(audioRenderer_ != nullptr);
499 audioRenderer_->SetRendererCallback(audioRendererMediaCallback_);
500 audioServiceDiedCallback_->SaveAudioPolicyServiceDiedCb(audioDiedCb);
501 audioRenderer_->RegisterAudioPolicyServerDiedCb(getpid(), audioServiceDiedCallback_);
502 }
503
SetAudioInterruptMode(int32_t interruptMode)504 void AudioSinkSvImpl::SetAudioInterruptMode(int32_t interruptMode)
505 {
506 MediaTrace trace("AudioSink::SetInterruptMode");
507 XcollieTimer xCollie("AudioRenderer::SetInterruptMode", PlayerXCollie::timerTimeout);
508 CHECK_AND_RETURN(audioRenderer_ != nullptr);
509 audioRenderer_->SetInterruptMode(static_cast<AudioStandard::InterruptMode>(interruptMode));
510 }
511
SetAudioEffectMode(int32_t effectMode)512 int32_t AudioSinkSvImpl::SetAudioEffectMode(int32_t effectMode)
513 {
514 MediaTrace trace("AudioSink::SetAudioEffectMode");
515 MEDIA_LOGD("SetAudioEffectMode %{public}d", effectMode);
516 XcollieTimer xCollie("AudioRenderer::SetAudioEffectMode", PlayerXCollie::timerTimeout);
517 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
518 int32_t ret = audioRenderer_->SetAudioEffectMode(static_cast<OHOS::AudioStandard::AudioEffectMode>(effectMode));
519 CHECK_AND_RETURN_RET_LOG(ret == AudioStandard::SUCCESS, ret, "failed to SetAudioEffectMode!");
520 return MSERR_OK;
521 }
522
GetAudioEffectMode(int32_t & effectMode)523 int32_t AudioSinkSvImpl::GetAudioEffectMode(int32_t &effectMode)
524 {
525 MediaTrace trace("AudioSink::GetAudioEffectMode");
526 XcollieTimer xCollie("AudioRenderer::GetAudioEffectMode", PlayerXCollie::timerTimeout);
527 CHECK_AND_RETURN_RET(audioRenderer_ != nullptr, MSERR_AUD_RENDER_FAILED);
528 effectMode = audioRenderer_->GetAudioEffectMode();
529 MEDIA_LOGD("GetAudioEffectMode %{public}d", effectMode);
530 return MSERR_OK;
531 }
532
SetAudioDumpBySysParam()533 void AudioSinkSvImpl::SetAudioDumpBySysParam()
534 {
535 std::string dump_enable;
536 enableDump_ = false;
537 int32_t res = OHOS::system::GetStringParameter("sys.media.dump.audiowrite.enable", dump_enable, "");
538 if (res != 0 || dump_enable.empty()) {
539 MEDIA_LOGI("sys.media.dump.audiowrite.enable is not set, dump audio is not required");
540 return;
541 }
542 MEDIA_LOGI("sys.media.dump.audiowrite.enable=%s", dump_enable.c_str());
543 if (dump_enable == "true") {
544 enableDump_ = true;
545 }
546 }
547
DumpAudioBuffer(uint8_t * buffer,const size_t & bytesWritten,const size_t & bytesSingle)548 void AudioSinkSvImpl::DumpAudioBuffer(uint8_t *buffer, const size_t &bytesWritten, const size_t &bytesSingle)
549 {
550 if (enableDump_ == false) {
551 return;
552 }
553
554 if (dumpFile_ == nullptr) {
555 std::string dumpFilePath = "/data/media/audio-write-" +
556 std::to_string(static_cast<int32_t>(FAKE_POINTER(this))) + ".pcm";
557 dumpFile_ = fopen(dumpFilePath.c_str(), "wb+");
558 }
559 CHECK_AND_RETURN(dumpFile_ != nullptr);
560 (void)fwrite(buffer + bytesWritten, bytesSingle, 1, dumpFile_);
561 (void)fflush(dumpFile_);
562 }
563 } // namespace Media
564 } // namespace OHOS
565