1 /*
2 * Copyright (c) 2022 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_container_client_base.h"
17 #include "audio_renderer_write_callback_stub.h"
18 #include <fstream>
19 #include "audio_log.h"
20 #include "securec.h"
21 #include "unistd.h"
22 #include "system_ability_definition.h"
23
24 using namespace std;
25
26 namespace OHOS {
27 namespace AudioStandard {
28
29 static const int32_t MAX_VOLUME_LEVEL = 15;
30 static const int32_t CONST_FACTOR = 100;
31
VolumeToDb(int32_t volumeLevel)32 static float VolumeToDb(int32_t volumeLevel)
33 {
34 float value = static_cast<float>(volumeLevel) / MAX_VOLUME_LEVEL;
35 float roundValue = static_cast<int>(value * CONST_FACTOR);
36
37 return static_cast<float>(roundValue) / CONST_FACTOR;
38 }
39
InitializeClientGa()40 void AudioContainerClientBase::InitializeClientGa()
41 {
42 mVolumeFactor = 1.0f;
43 mStreamType = STREAM_MUSIC;
44 mAudioSystemMgr = nullptr;
45 renderRate = RENDER_RATE_NORMAL;
46 renderMode_ = RENDER_MODE_NORMAL;
47 eAudioClientType = AUDIO_SERVICE_CLIENT_PLAYBACK;
48 mFrameSize = 0;
49 mFrameMarkPosition = 0;
50 mMarkReached = false;
51 mFramePeriodNumber = 0;
52 mTotalBytesWritten = 0;
53 mFramePeriodWritten = 0;
54 mTotalBytesRead = 0;
55 mFramePeriodRead = 0;
56
57 mRenderPositionCb = nullptr;
58 mRenderPeriodPositionCb = nullptr;
59 mAudioRendererCallbacks = nullptr;
60 mAudioCapturerCallbacks = nullptr;
61 internalReadBuffer_ = nullptr;
62
63 internalRdBufIndex_ = 0;
64 internalRdBufLen_ = 0;
65 }
66
ResetPAAudioClientGa()67 void AudioContainerClientBase::ResetPAAudioClientGa()
68 {
69 lock_guard<mutex> lock(ctrlMutex_);
70 mAudioRendererCallbacks = nullptr;
71 mAudioCapturerCallbacks = nullptr;
72 internalReadBuffer_ = nullptr;
73
74 internalRdBufIndex_ = 0;
75 internalRdBufLen_ = 0;
76 }
77
AudioContainerClientBase(const sptr<IRemoteObject> & impl)78 AudioContainerClientBase::AudioContainerClientBase(const sptr<IRemoteObject> &impl)
79 :IRemoteProxy<IAudioContainerService>(impl)
80 {
81 }
82
~AudioContainerClientBase()83 AudioContainerClientBase::~AudioContainerClientBase()
84 {
85 ResetPAAudioClientGa();
86 }
87
InitializeGa(ASClientType eClientType)88 int32_t AudioContainerClientBase::InitializeGa(ASClientType eClientType)
89 {
90 AUDIO_DEBUG_LOG("AudioContainerClientBase::InitializeGa begin.");
91 InitializeClientGa();
92 eAudioClientType = eClientType;
93
94 mMarkReached = false;
95 mTotalBytesWritten = 0;
96 mFramePeriodWritten = 0;
97 mTotalBytesRead = 0;
98 mFramePeriodRead = 0;
99
100 mAudioSystemMgr = AudioSystemManager::GetInstance();
101
102 return AUDIO_CLIENT_SUCCESS;
103 }
104
GetStreamNameGa(AudioStreamType audioType)105 const std::string AudioContainerClientBase::GetStreamNameGa(AudioStreamType audioType)
106 {
107 std::string name;
108 switch (audioType) {
109 case STREAM_VOICE_ASSISTANT:
110 name = "voice_assistant";
111 break;
112 case STREAM_VOICE_CALL:
113 name = "voice_call";
114 break;
115 case STREAM_SYSTEM:
116 name = "system";
117 break;
118 case STREAM_RING:
119 name = "ring";
120 break;
121 case STREAM_MUSIC:
122 name = "music";
123 break;
124 case STREAM_ALARM:
125 name = "alarm";
126 break;
127 case STREAM_NOTIFICATION:
128 name = "notification";
129 break;
130 case STREAM_BLUETOOTH_SCO:
131 name = "bluetooth_sco";
132 break;
133 case STREAM_DTMF:
134 name = "dtmf";
135 break;
136 case STREAM_TTS:
137 name = "tts";
138 break;
139 case STREAM_ACCESSIBILITY:
140 name = "accessibility";
141 break;
142 case STREAM_WAKEUP:
143 name = "wakeup";
144 break;
145 default:
146 name = "unknown";
147 }
148
149 const std::string streamName = name;
150 return streamName;
151 }
152
InitializeAudioCacheGa()153 int32_t AudioContainerClientBase::InitializeAudioCacheGa()
154 {
155 return AUDIO_CLIENT_SUCCESS;
156 }
157
CreateStreamGa(AudioStreamParams audioParams,AudioStreamType audioType)158 int32_t AudioContainerClientBase::CreateStreamGa(AudioStreamParams audioParams, AudioStreamType audioType)
159 {
160 int32_t error;
161
162 if (eAudioClientType == AUDIO_SERVICE_CLIENT_CONTROLLER) {
163 return AUDIO_CLIENT_INVALID_PARAMS_ERR;
164 }
165
166 MessageParcel data;
167 MessageParcel reply;
168 MessageOption option;
169 if (!data.WriteInterfaceToken(GetDescriptor())) {
170 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
171 return AUDIO_CLIENT_ERR;
172 }
173 data.WriteInt32(static_cast<int32_t>(audioParams.samplingRate));
174 data.WriteInt32(static_cast<int32_t>(audioParams.encoding));
175 data.WriteInt32(static_cast<int32_t>(audioParams.format));
176 data.WriteInt32(static_cast<int32_t>(audioParams.channels));
177 data.WriteInt32(static_cast<int32_t>(audioType));
178
179 error = Remote()->SendRequest(CMD_CREATE_AUDIOSTREAM, data, reply, option);
180
181 mFrameSize = (static_cast<uint32_t>(audioParams.channels)) * (static_cast<uint32_t>(audioParams.format));
182 if (error != ERR_NONE) {
183 AUDIO_ERR_LOG("AudioContainerClientBase::CreateRemoteAudioRenderer() failed, error: %{public}d", error);
184 return AUDIO_CLIENT_CREATE_STREAM_ERR;
185 }
186
187 audioTrackId = reply.ReadInt32();
188 if (audioTrackId < 0) {
189 AUDIO_ERR_LOG("AudioContainerClientBase: CreateRemoteAudioRenderer() remote failed");
190 return AUDIO_CLIENT_CREATE_STREAM_ERR;
191 }
192 state_ = PREPARED;
193 std::shared_ptr<AudioStreamCallback> streamCb = streamCallback_.lock();
194 if (streamCb != nullptr) {
195 streamCb->OnStateChange(state_);
196 }
197
198 AUDIO_INFO_LOG("AudioContainerClientBase: Created Stream SUCCESS TrackId %{public}d", audioTrackId);
199 return audioTrackId;
200 }
201
StartStreamGa(const int32_t & trackId)202 int32_t AudioContainerClientBase::StartStreamGa(const int32_t &trackId)
203 {
204 lock_guard<mutex> lock(ctrlMutex_);
205 MessageParcel data;
206 MessageParcel reply;
207 MessageOption option;
208 if (!data.WriteInterfaceToken(GetDescriptor())) {
209 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
210 return AUDIO_CLIENT_ERR;
211 }
212 data.WriteInt32(trackId);
213 int32_t error = Remote()->SendRequest(CMD_START_AUDIOSTREAM, data, reply, option);
214 if (error != ERR_NONE) {
215 AUDIO_ERR_LOG("AudioContainerClientBase: StartStreamGa() failed, error: %{public}d", error);
216 return AUDIO_CLIENT_START_STREAM_ERR;
217 }
218 AUDIO_INFO_LOG("AudioContainerClientBase: Start Stream SUCCESS");
219 return AUDIO_CLIENT_SUCCESS;
220 }
221
PauseStreamGa(const int32_t & trackId)222 int32_t AudioContainerClientBase::PauseStreamGa(const int32_t &trackId)
223 {
224 lock_guard<mutex> lock(ctrlMutex_);
225 MessageParcel data;
226 MessageParcel reply;
227 MessageOption option;
228 if (!data.WriteInterfaceToken(GetDescriptor())) {
229 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
230 return AUDIO_CLIENT_ERR;
231 }
232 data.WriteInt32(trackId);
233 int32_t error = Remote()->SendRequest(CMD_PAUSE_AUDIOSTREAM, data, reply, option);
234 if (error != ERR_NONE) {
235 AUDIO_ERR_LOG("AudioContainerClientBase: PauseStreamGa() failed, error: %{public}d", error);
236 return AUDIO_CLIENT_ERR;
237 }
238
239 return AUDIO_CLIENT_SUCCESS;
240 }
241
StopStreamGa(const int32_t & trackId)242 int32_t AudioContainerClientBase::StopStreamGa(const int32_t &trackId)
243 {
244 lock_guard<mutex> lock(ctrlMutex_);
245 MessageParcel data;
246 MessageParcel reply;
247 MessageOption option;
248 if (!data.WriteInterfaceToken(GetDescriptor())) {
249 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
250 return AUDIO_CLIENT_ERR;
251 }
252 data.WriteInt32(trackId);
253 int32_t error = Remote()->SendRequest(CMD_STOP_AUDIOSTREAM, data, reply, option);
254 if (error != ERR_NONE) {
255 AUDIO_ERR_LOG("AudioContainerClientBase: StopStreamGa() failed, error: %{public}d", error);
256 return AUDIO_CLIENT_ERR;
257 }
258
259 return AUDIO_CLIENT_SUCCESS;
260 }
261
FlushStreamGa(const int32_t & trackId)262 int32_t AudioContainerClientBase::FlushStreamGa(const int32_t &trackId)
263 {
264 lock_guard<mutex> lock(dataMutex_);
265 MessageParcel data;
266 MessageParcel reply;
267 MessageOption option;
268 if (!data.WriteInterfaceToken(GetDescriptor())) {
269 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
270 return AUDIO_CLIENT_ERR;
271 }
272 data.WriteInt32(trackId);
273 int32_t error = Remote()->SendRequest(CMD_FLUSH_AUDIOSTREAM, data, reply, option);
274 if (error != ERR_NONE) {
275 AUDIO_ERR_LOG("AudioContainerClientBase: FlushStreamGa() failed, error: %{public}d", error);
276 return AUDIO_CLIENT_ERR;
277 }
278
279 return AUDIO_CLIENT_SUCCESS;
280 }
281
DrainStreamGa(const int32_t & trackId)282 int32_t AudioContainerClientBase::DrainStreamGa(const int32_t &trackId)
283 {
284 return AUDIO_CLIENT_SUCCESS;
285 }
286
GetSessionIDGa(uint32_t & sessionID,const int32_t & trackId)287 int32_t AudioContainerClientBase::GetSessionIDGa(uint32_t &sessionID, const int32_t &trackId)
288 {
289 MessageParcel data;
290 MessageParcel reply;
291 MessageOption option;
292 if (!data.WriteInterfaceToken(GetDescriptor())) {
293 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
294 return AUDIO_CLIENT_ERR;
295 }
296 data.WriteInt32(trackId);
297 int32_t error = Remote()->SendRequest(CMD_GET_AUDIO_SESSIONID, data, reply, option);
298 if (error != ERR_NONE) {
299 AUDIO_ERR_LOG("AudioContainerClientBase: GetSessinIDGa() failed, error: %{public}d", error);
300 return AUDIO_CLIENT_ERR;
301 }
302 sessionID = reply.ReadInt32();
303 return AUDIO_CLIENT_SUCCESS;
304 }
305
SetAudioRenderModeGa(AudioRenderMode renderMode,const int32_t & trackId)306 int32_t AudioContainerClientBase::SetAudioRenderModeGa(AudioRenderMode renderMode, const int32_t &trackId)
307 {
308 renderMode_ = renderMode;
309 if (renderMode_ != RENDER_MODE_CALLBACK) {
310 return AUDIO_CLIENT_SUCCESS;
311 }
312 MessageParcel data;
313 MessageParcel reply;
314 MessageOption option;
315 if (!data.WriteInterfaceToken(GetDescriptor())) {
316 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
317 return AUDIO_CLIENT_ERR;
318 }
319 data.WriteInt32(static_cast<int32_t>(renderMode));
320 data.WriteInt32(trackId);
321 int32_t error = Remote()->SendRequest(CMD_SET_AUDIORENDERER_MODE, data, reply, option);
322 if (error != ERR_NONE) {
323 AUDIO_ERR_LOG("AudioContainerClientBase: SetAudioRenderModeGa() failed, error: %{public}d", error);
324 return AUDIO_CLIENT_ERR;
325 }
326
327 return AUDIO_CLIENT_SUCCESS;
328 }
329
GetAudioRenderModeGa()330 AudioRenderMode AudioContainerClientBase::GetAudioRenderModeGa()
331 {
332 return renderMode_;
333 }
334
SaveWriteCallbackGa(const std::weak_ptr<AudioRendererWriteCallback> & callback,const int32_t & trackId)335 int32_t AudioContainerClientBase::SaveWriteCallbackGa(const std::weak_ptr<AudioRendererWriteCallback> &callback,
336 const int32_t &trackId)
337 {
338 AUDIO_ERR_LOG("AudioContainerClientBase: SaveWriteCallbackGa");
339 lock_guard<mutex> lock(dataMutex_);
340 MessageParcel data;
341 MessageParcel reply;
342 MessageOption option;
343 if (callback.lock() == nullptr) {
344 AUDIO_ERR_LOG("AudioContainerClientBase: SaveWriteCallbackGa callback.lock() == nullpt");
345 return AUDIO_CLIENT_INIT_ERR;
346 }
347 writeCallback_ = callback;
348 // construct writecallback stub for remote
349 sptr<AudioRendererWriteCallbackStub> writeCallbackStub = new(std::nothrow) AudioRendererWriteCallbackStub();
350 if (writeCallbackStub == nullptr) {
351 AUDIO_ERR_LOG("AudioContainerClientBase: SaveWriteCallbackGa writeCallbackStub == nullpt");
352 return AUDIO_CLIENT_ERR;
353 }
354 writeCallbackStub->SetOnRendererWriteCallback(callback);
355 sptr<IRemoteObject> object = writeCallbackStub->AsObject();
356 if (object == nullptr) {
357 AUDIO_ERR_LOG("AudioContainerClientBase: SaveWriteCallbackGa writeCallbackStub->AsObject is nullpt");
358 return AUDIO_CLIENT_ERR;
359 }
360
361 if (!data.WriteInterfaceToken(GetDescriptor())) {
362 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
363 return AUDIO_CLIENT_ERR;
364 }
365
366 data.WriteRemoteObject(object);
367 data.WriteInt32(trackId);
368 int32_t error = Remote()->SendRequest(CMD_WRITE_RENDERER_CALLBACK, data, reply, option);
369 if (error != ERR_NONE) {
370 AUDIO_ERR_LOG("AudioContainerClientBase: SaveWriteCallbackGa() failed, error: %{public}d", error);
371 return AUDIO_CLIENT_ERR;
372 }
373
374 return AUDIO_CLIENT_SUCCESS;
375 }
376
SetStreamVolumeGa(uint32_t sessionID,uint32_t volume)377 int32_t AudioContainerClientBase::SetStreamVolumeGa(uint32_t sessionID, uint32_t volume)
378 {
379 return AUDIO_CLIENT_SUCCESS;
380 }
381
WriteStreamInnerGa(const uint8_t * buffer,size_t & length,const int32_t & trackId)382 int32_t AudioContainerClientBase::WriteStreamInnerGa(const uint8_t *buffer, size_t &length, const int32_t &trackId)
383 {
384 MessageParcel data;
385 MessageParcel reply;
386 MessageOption option;
387 if (!data.WriteInterfaceToken(GetDescriptor())) {
388 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
389 return AUDIO_CLIENT_ERR;
390 }
391 data.WriteInt32(static_cast<int32_t>(length));
392 data.WriteBuffer(static_cast<const void *>(buffer), length);
393 data.WriteInt32(trackId);
394 int32_t error = Remote()->SendRequest(CMD_WRITE_AUDIOSTREAM, data, reply, option);
395 if (error != ERR_NONE) {
396 AUDIO_ERR_LOG("AudioContainerClientBase::WriteStreamInnerGa() failed, error: %{public}d", error);
397 return AUDIO_CLIENT_ERR;
398 }
399 HandleRenderPositionCallbacksGa(length);
400 return AUDIO_CLIENT_SUCCESS;
401 }
402
HandleRenderPositionCallbacksGa(size_t bytesWritten)403 void AudioContainerClientBase::HandleRenderPositionCallbacksGa(size_t bytesWritten)
404 {
405 mTotalBytesWritten += bytesWritten;
406 if (mFrameSize == 0) {
407 return;
408 }
409
410 uint64_t writtenFrameNumber = mTotalBytesWritten / mFrameSize;
411 if (!mMarkReached && mRenderPositionCb) {
412 if (writtenFrameNumber >= mFrameMarkPosition) {
413 mRenderPositionCb->OnMarkReached(mFrameMarkPosition);
414 mPositionCBThreads.emplace_back(std::make_unique<std::thread>(&RendererPositionCallback::OnMarkReached,
415 mRenderPositionCb, mFrameMarkPosition));
416 mMarkReached = true;
417 }
418 }
419
420 if (mRenderPeriodPositionCb) {
421 mFramePeriodWritten += (bytesWritten / mFrameSize);
422 if (mFramePeriodWritten >= mFramePeriodNumber) {
423 mRenderPeriodPositionCb->OnPeriodReached(mFramePeriodNumber);
424 mFramePeriodWritten %= mFramePeriodNumber;
425 mPeriodPositionCBThreads.emplace_back(std::make_unique<std::thread>(
426 &RendererPeriodPositionCallback::OnPeriodReached, mRenderPeriodPositionCb, mFramePeriodNumber));
427 }
428 }
429 }
430
WriteStreamInCbGa(const StreamBuffer & stream,int32_t & pError,const int32_t & trackId)431 size_t AudioContainerClientBase::WriteStreamInCbGa(const StreamBuffer &stream, int32_t &pError, const int32_t &trackId)
432 {
433 lock_guard<mutex> lock(dataMutex_);
434
435 const uint8_t *buffer = stream.buffer;
436 size_t length = stream.bufferLen;
437 pError = WriteStreamInnerGa(buffer, length, trackId);
438
439 return (stream.bufferLen - length);
440 }
441
WriteStreamGa(const StreamBuffer & stream,int32_t & pError,const int32_t & trackId)442 size_t AudioContainerClientBase::WriteStreamGa(const StreamBuffer &stream, int32_t &pError, const int32_t &trackId)
443 {
444 lock_guard<mutex> lock(dataMutex_);
445 int error = 0;
446 const uint8_t *inputBuffer = stream.buffer;
447 size_t inputLength = stream.bufferLen;
448 if (inputBuffer == nullptr) {
449 AUDIO_ERR_LOG("WriteStreamGa inputBuffer is null");
450 return 0;
451 }
452 error = WriteStreamInnerGa(inputBuffer, inputLength, trackId);
453
454 pError = error;
455 return inputLength;
456 }
457
UpdateReadBufferGa(uint8_t * buffer,size_t & length,size_t & readSize)458 int32_t AudioContainerClientBase::UpdateReadBufferGa(uint8_t *buffer, size_t &length, size_t &readSize)
459 {
460 size_t l = (internalRdBufLen_ < length) ? internalRdBufLen_ : length;
461 if (memcpy_s(buffer, length, static_cast<const uint8_t*>(internalReadBuffer_) + internalRdBufIndex_, l)) {
462 return AUDIO_CLIENT_READ_STREAM_ERR;
463 }
464
465 length -= l;
466 internalRdBufIndex_ += l;
467 internalRdBufLen_ -= l;
468 readSize += l;
469
470 if (!internalRdBufLen_) {
471 internalReadBuffer_ = nullptr;
472 internalRdBufLen_ = 0;
473 internalRdBufIndex_ = 0;
474 }
475
476 return AUDIO_CLIENT_SUCCESS;
477 }
478
HandleCapturePositionCallbacksGa(size_t bytesRead)479 void AudioContainerClientBase::HandleCapturePositionCallbacksGa(size_t bytesRead)
480 {
481 mTotalBytesRead += bytesRead;
482 if (mFrameSize == 0) {
483 AUDIO_ERR_LOG("AudioContainerClientBase: HandleCapturePositionCallbacksGa capturerPeriodPositionCb not set");
484 return;
485 }
486
487 uint64_t readFrameNumber = mTotalBytesRead / mFrameSize;
488 if (!mMarkReached && mCapturePositionCb) {
489 if (readFrameNumber >= mFrameMarkPosition) {
490 mCapturePositionCb->OnMarkReached(mFrameMarkPosition);
491 mPositionCBThreads.emplace_back(std::make_unique<std::thread>(&CapturerPositionCallback::OnMarkReached,
492 mCapturePositionCb, mFrameMarkPosition));
493 mMarkReached = true;
494 }
495 }
496
497 if (mCapturePeriodPositionCb) {
498 mFramePeriodRead += (bytesRead / mFrameSize);
499 if (mFramePeriodRead >= mFramePeriodNumber) {
500 mCapturePeriodPositionCb->OnPeriodReached(mFramePeriodNumber);
501 mFramePeriodRead %= mFramePeriodNumber;
502 mPeriodPositionCBThreads.emplace_back(std::make_unique<std::thread>(
503 &CapturerPeriodPositionCallback::OnPeriodReached, mCapturePeriodPositionCb, mFramePeriodNumber));
504 }
505 }
506 }
507
ReadStreamGa(StreamBuffer & stream,bool isBlocking,const int32_t & trackId)508 int32_t AudioContainerClientBase::ReadStreamGa(StreamBuffer &stream, bool isBlocking, const int32_t &trackId)
509 {
510 lock_guard<mutex> lock(dataMutex_);
511 MessageParcel data;
512 MessageParcel reply;
513 MessageOption option;
514 if (!data.WriteInterfaceToken(GetDescriptor())) {
515 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
516 return AUDIO_CLIENT_ERR;
517 }
518 data.WriteInt32(static_cast<int32_t>(stream.bufferLen));
519 data.WriteInt32(trackId);
520 int32_t error = Remote()->SendRequest(CMD_READ_STREAM, data, reply, option);
521 if (error != ERR_NONE) {
522 AUDIO_ERR_LOG("AudioContainerClientBase: ReadStreamGa() failed, error: %{public}d", error);
523 return AUDIO_CLIENT_ERR;
524 }
525 reply.ReadUint32(stream.bufferLen);
526 size_t readSize = static_cast<size_t>(stream.bufferLen);
527
528 const uint8_t *buffer = reply.ReadBuffer(readSize);
529 memcpy_s(stream.buffer, readSize, buffer, readSize);
530 return readSize;
531 }
532
ReleaseStreamGa(const int32_t & trackId)533 int32_t AudioContainerClientBase::ReleaseStreamGa(const int32_t &trackId)
534 {
535 MessageParcel data;
536 MessageParcel reply;
537 MessageOption option;
538 if (!data.WriteInterfaceToken(GetDescriptor())) {
539 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
540 return AUDIO_CLIENT_ERR;
541 }
542 data.WriteInt32(trackId);
543 int32_t error = Remote()->SendRequest(CMD_RELEASE_AUDIOSTREAM, data, reply, option);
544 if (error != ERR_NONE) {
545 AUDIO_ERR_LOG("AudioContainerClientBase: ReleaseStreamGa() failed, error: %{public}d", error);
546 return AUDIO_CLIENT_ERR;
547 }
548
549 ResetPAAudioClientGa();
550 state_ = RELEASED;
551
552 std::shared_ptr<AudioStreamCallback> streamCb = streamCallback_.lock();
553 if (streamCb != nullptr) {
554 streamCb->OnStateChange(state_);
555 }
556
557 return AUDIO_CLIENT_SUCCESS;
558 }
559
GetMinimumBufferSizeGa(size_t & minBufferSize,const int32_t & trackId)560 int32_t AudioContainerClientBase::GetMinimumBufferSizeGa(size_t &minBufferSize, const int32_t &trackId)
561 {
562 MessageParcel data;
563 MessageParcel reply;
564 MessageOption option;
565 if (!data.WriteInterfaceToken(GetDescriptor())) {
566 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
567 return AUDIO_CLIENT_ERR;
568 }
569 data.WriteInt32(trackId);
570 int32_t error = Remote()->SendRequest(CMD_GET_MINIMUM_BUFFERSIZE, data, reply, option);
571 if (error != ERR_NONE) {
572 AUDIO_ERR_LOG("AudioContainerClientBase: GetMinimumBufferSizeGa() failed, error: %{public}d", error);
573 return AUDIO_CLIENT_ERR;
574 }
575
576 minBufferSize = static_cast<size_t>(reply.ReadInt64());
577
578 return AUDIO_CLIENT_SUCCESS;
579 }
580
GetMinimumFrameCountGa(uint32_t & frameCount,const int32_t & trackId)581 int32_t AudioContainerClientBase::GetMinimumFrameCountGa(uint32_t &frameCount, const int32_t &trackId)
582 {
583 MessageParcel data;
584 MessageParcel reply;
585 MessageOption option;
586 if (!data.WriteInterfaceToken(GetDescriptor())) {
587 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
588 return AUDIO_CLIENT_ERR;
589 }
590 data.WriteInt32(trackId);
591 int32_t error = Remote()->SendRequest(CMD_GET_MINIMUM_FRAMECOUNT, data, reply, option);
592 if (error != ERR_NONE) {
593 AUDIO_ERR_LOG("AudioContainerClientBase: GetMinimumFrameCountGa() failed, error: %{public}d", error);
594 return AUDIO_CLIENT_ERR;
595 }
596
597 reply.ReadUint32(frameCount);
598
599 return AUDIO_CLIENT_SUCCESS;
600 }
601
SetBufferSizeInMsecGa(int32_t bufferSizeInMsec)602 int32_t AudioContainerClientBase::SetBufferSizeInMsecGa(int32_t bufferSizeInMsec)
603 {
604 return AUDIO_CLIENT_SUCCESS;
605 }
606
GetSamplingRateGa() const607 uint32_t AudioContainerClientBase::GetSamplingRateGa() const
608 {
609 return DEFAULT_SAMPLING_RATE;
610 }
611
GetChannelCountGa() const612 uint8_t AudioContainerClientBase::GetChannelCountGa() const
613 {
614 return DEFAULT_CHANNEL_COUNT;
615 }
616
GetSampleSizeGa() const617 uint8_t AudioContainerClientBase::GetSampleSizeGa() const
618 {
619 return DEFAULT_SAMPLE_SIZE;
620 }
621
GetAudioStreamParamsGa(AudioStreamParams & audioParams,const int32_t & trackId)622 int32_t AudioContainerClientBase::GetAudioStreamParamsGa(AudioStreamParams &audioParams, const int32_t &trackId)
623 {
624 MessageParcel data;
625 MessageParcel reply;
626 MessageOption option;
627 if (!data.WriteInterfaceToken(GetDescriptor())) {
628 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
629 return AUDIO_CLIENT_ERR;
630 }
631 data.WriteInt32(trackId);
632 int32_t error = Remote()->SendRequest(CMD_GET_AUDIOSTREAM_PARAMS, data, reply, option);
633 if (error != ERR_NONE) {
634 AUDIO_ERR_LOG("AudioContainerClientBase: GetAudioStreamParamsGa() failed, error: %{public}d", error);
635 return AUDIO_CLIENT_ERR;
636 }
637 reply.ReadUint32(audioParams.samplingRate);
638 reply.ReadUint8(audioParams.encoding);
639 reply.ReadUint8(audioParams.format);
640 reply.ReadUint8(audioParams.channels);
641 return AUDIO_CLIENT_SUCCESS;
642 }
643
GetStreamVolumeGa()644 float AudioContainerClientBase::GetStreamVolumeGa()
645 {
646 return mVolumeFactor;
647 }
648
GetStreamVolumeGa(uint32_t sessionID)649 uint32_t AudioContainerClientBase::GetStreamVolumeGa(uint32_t sessionID)
650 {
651 return DEFAULT_STREAM_VOLUME;
652 }
653
SetStreamVolumeGa(float volume,const int32_t & trackId)654 int32_t AudioContainerClientBase::SetStreamVolumeGa(float volume, const int32_t &trackId)
655 {
656 lock_guard<mutex> lock(ctrlMutex_);
657 if ((volume < MIN_STREAM_VOLUME_LEVEL) || (volume > MAX_STREAM_VOLUME_LEVEL)) {
658 return AUDIO_CLIENT_INVALID_PARAMS_ERR;
659 }
660 mVolumeFactor = volume;
661 int32_t systemVolumeLevel = mAudioSystemMgr->GetVolume(static_cast<AudioVolumeType>(mStreamType));
662 float systemVolumeDb = VolumeToDb(systemVolumeLevel);
663 float vol = systemVolumeDb * mVolumeFactor;
664
665 AudioRingerMode ringerMode = mAudioSystemMgr->GetRingerMode();
666 if ((mStreamType == STREAM_RING) && (ringerMode != RINGER_MODE_NORMAL)) {
667 vol = MIN_STREAM_VOLUME_LEVEL;
668 }
669
670 MessageParcel data;
671 MessageParcel reply;
672 MessageOption option;
673 if (!data.WriteInterfaceToken(GetDescriptor())) {
674 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
675 return AUDIO_CLIENT_ERR;
676 }
677 data.WriteFloat(vol);
678 data.WriteInt32(trackId);
679 int32_t error = Remote()->SendRequest(CMD_SET_STREAM_VOLUME, data, reply, option);
680 if (error != ERR_NONE) {
681 AUDIO_ERR_LOG("AudioContainerClientBase: SetStreamVolumeGa() failed, error: %{public}d", error);
682 return AUDIO_CLIENT_ERR;
683 }
684
685 return AUDIO_CLIENT_SUCCESS;
686 }
687
GetCurrentTimeStampGa(uint64_t & timeStamp,const int32_t & trackId)688 int32_t AudioContainerClientBase::GetCurrentTimeStampGa(uint64_t &timeStamp, const int32_t &trackId)
689 {
690 MessageParcel data;
691 MessageParcel reply;
692 MessageOption option;
693 if (!data.WriteInterfaceToken(GetDescriptor())) {
694 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
695 return AUDIO_CLIENT_ERR;
696 }
697 data.WriteInt32(trackId);
698 int32_t error = Remote()->SendRequest(CMD_GET_CURRENT_TIMESTAMP, data, reply, option);
699 if (error != ERR_NONE) {
700 AUDIO_ERR_LOG("AudioContainerClientBase: GetCurrentTimeStampGa() failed, error: %{public}d", error);
701 return AUDIO_CLIENT_ERR;
702 }
703
704 reply.ReadUint64(timeStamp);
705
706 return AUDIO_CLIENT_SUCCESS;
707 }
708
GetAudioLatencyGa(uint64_t & latency,const int32_t & trackId)709 int32_t AudioContainerClientBase::GetAudioLatencyGa(uint64_t &latency, const int32_t &trackId)
710 {
711 MessageParcel data;
712 MessageParcel reply;
713 MessageOption option;
714 if (!data.WriteInterfaceToken(GetDescriptor())) {
715 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
716 return AUDIO_CLIENT_ERR;
717 }
718 data.WriteInt32(trackId);
719 int32_t error = Remote()->SendRequest(CMD_GET_AUDIO_LATENCY, data, reply, option);
720 if (error != ERR_NONE) {
721 AUDIO_ERR_LOG("AudioContainerClientBase: GetAudioLatencyGa() failed, error: %{public}d", error);
722 return AUDIO_CLIENT_ERR;
723 }
724
725 reply.ReadUint64(latency);
726
727 return AUDIO_CLIENT_SUCCESS;
728 }
729
RegisterAudioRendererCallbackGa(const AudioRendererCallback & cb)730 void AudioContainerClientBase::RegisterAudioRendererCallbackGa(const AudioRendererCallback &cb)
731 {
732 AUDIO_DEBUG_LOG("Registering audio render callbacks");
733 mAudioRendererCallbacks = (AudioRendererCallback *)&cb;
734 }
735
RegisterAudioCapturerCallbackGa(const AudioCapturerCallback & cb)736 void AudioContainerClientBase::RegisterAudioCapturerCallbackGa(const AudioCapturerCallback &cb)
737 {
738 AUDIO_DEBUG_LOG("Registering audio recorder callbacks");
739 mAudioCapturerCallbacks = (AudioCapturerCallback *)&cb;
740 }
741
SetRendererPositionCallbackGa(int64_t markPosition,const std::shared_ptr<RendererPositionCallback> & callback)742 void AudioContainerClientBase::SetRendererPositionCallbackGa(int64_t markPosition,
743 const std::shared_ptr<RendererPositionCallback> &callback)
744 {
745 mFrameMarkPosition = markPosition;
746 mRenderPositionCb = callback;
747 }
748
UnsetRendererPositionCallbackGa()749 void AudioContainerClientBase::UnsetRendererPositionCallbackGa()
750 {
751 mRenderPositionCb = nullptr;
752 mMarkReached = false;
753 mFrameMarkPosition = 0;
754 }
755
SetRendererPeriodPositionCallbackGa(int64_t periodPosition,const std::shared_ptr<RendererPeriodPositionCallback> & callback)756 void AudioContainerClientBase::SetRendererPeriodPositionCallbackGa(int64_t periodPosition,
757 const std::shared_ptr<RendererPeriodPositionCallback> &callback)
758 {
759 mFramePeriodNumber = periodPosition;
760 if (mFrameSize != 0 && mFramePeriodNumber != 0) {
761 mFramePeriodWritten = (mTotalBytesWritten / mFrameSize) % mFramePeriodNumber;
762 } else {
763 return;
764 }
765
766 mRenderPeriodPositionCb = callback;
767 }
768
UnsetRendererPeriodPositionCallbackGa()769 void AudioContainerClientBase::UnsetRendererPeriodPositionCallbackGa()
770 {
771 mRenderPeriodPositionCb = nullptr;
772 mFramePeriodWritten = 0;
773 mFramePeriodNumber = 0;
774 }
775
SetCapturerPositionCallbackGa(int64_t markPosition,const std::shared_ptr<CapturerPositionCallback> & callback)776 void AudioContainerClientBase::SetCapturerPositionCallbackGa(int64_t markPosition,
777 const std::shared_ptr<CapturerPositionCallback> &callback)
778 {
779 mFrameMarkPosition = markPosition;
780 mCapturePositionCb = callback;
781 }
782
UnsetCapturerPositionCallbackGa()783 void AudioContainerClientBase::UnsetCapturerPositionCallbackGa()
784 {
785 mCapturePositionCb = nullptr;
786 mMarkReached = false;
787 mFrameMarkPosition = 0;
788 }
789
SetCapturerPeriodPositionCallbackGa(int64_t periodPosition,const std::shared_ptr<CapturerPeriodPositionCallback> & callback)790 void AudioContainerClientBase::SetCapturerPeriodPositionCallbackGa(int64_t periodPosition,
791 const std::shared_ptr<CapturerPeriodPositionCallback> &callback)
792 {
793 mFramePeriodNumber = periodPosition;
794 if (mFrameSize != 0 && mFramePeriodNumber != 0) {
795 mFramePeriodRead = (mTotalBytesRead / mFrameSize) % mFramePeriodNumber;
796 } else {
797 return;
798 }
799
800 mCapturePeriodPositionCb = callback;
801 }
802
UnsetCapturerPeriodPositionCallbackGa()803 void AudioContainerClientBase::UnsetCapturerPeriodPositionCallbackGa()
804 {
805 mCapturePeriodPositionCb = nullptr;
806 mFramePeriodRead = 0;
807 mFramePeriodNumber = 0;
808 }
809
SetStreamTypeGa(AudioStreamType audioStreamType,const int32_t & trackId)810 int32_t AudioContainerClientBase::SetStreamTypeGa(AudioStreamType audioStreamType, const int32_t &trackId)
811 {
812 MessageParcel data;
813 MessageParcel reply;
814 MessageOption option;
815 if (!data.WriteInterfaceToken(GetDescriptor())) {
816 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
817 return AUDIO_CLIENT_ERR;
818 }
819
820 data.WriteInt32(static_cast<int32_t>(audioStreamType));
821 data.WriteInt32(trackId);
822 int32_t error = Remote()->SendRequest(CMD_SET_STREAM_TYPE, data, reply, option);
823 if (error != ERR_NONE) {
824 AUDIO_ERR_LOG("AudioContainerClientBase: SetStreamTypeGa() failed, error: %{public}d", error);
825 return AUDIO_CLIENT_ERR;
826 }
827
828 return AUDIO_CLIENT_SUCCESS;
829 }
830
SetStreamRenderRateGa(AudioRendererRate audioRendererRate,const int32_t & trackId)831 int32_t AudioContainerClientBase::SetStreamRenderRateGa(AudioRendererRate audioRendererRate, const int32_t &trackId)
832 {
833 renderRate = audioRendererRate;
834 uint32_t rate = renderRate;
835
836 MessageParcel data;
837 MessageParcel reply;
838 MessageOption option;
839 if (!data.WriteInterfaceToken(GetDescriptor())) {
840 AUDIO_ERR_LOG("AudioContainerClientBase: WriteInterfaceToken failed");
841 return AUDIO_CLIENT_ERR;
842 }
843
844 data.WriteUint32(rate);
845 data.WriteInt32(trackId);
846 int32_t error = Remote()->SendRequest(CMD_SET_STREAM_RENDER_RATE, data, reply, option);
847 if (error != ERR_NONE) {
848 AUDIO_ERR_LOG("AudioContainerClientBase: SetStreamRenderRateGa() failed, error: %{public}d", error);
849 return AUDIO_CLIENT_ERR;
850 }
851
852 return AUDIO_CLIENT_SUCCESS;
853 }
854
GetStreamRenderRateGa()855 AudioRendererRate AudioContainerClientBase::GetStreamRenderRateGa()
856 {
857 return renderRate;
858 }
859
SaveStreamCallbackGa(const std::weak_ptr<AudioStreamCallback> & callback)860 void AudioContainerClientBase::SaveStreamCallbackGa(const std::weak_ptr<AudioStreamCallback> &callback)
861 {
862 streamCallback_ = callback;
863
864 if (state_ != PREPARED) {
865 return;
866 }
867
868 std::shared_ptr<AudioStreamCallback> streamCb = streamCallback_.lock();
869 if (streamCb != nullptr) {
870 streamCb->OnStateChange(state_);
871 }
872 }
873
SetAudioCaptureMode(AudioCaptureMode captureMode)874 int32_t AudioContainerClientBase::SetAudioCaptureMode(AudioCaptureMode captureMode)
875 {
876 return AUDIO_CLIENT_SUCCESS;
877 }
878
SaveReadCallback(const std::weak_ptr<AudioCapturerReadCallback> & callback)879 int32_t AudioContainerClientBase::SaveReadCallback(const std::weak_ptr<AudioCapturerReadCallback> &callback)
880 {
881 return AUDIO_CLIENT_SUCCESS;
882 }
883
GetAudioCaptureMode()884 AudioCaptureMode AudioContainerClientBase::GetAudioCaptureMode()
885 {
886 return AudioCaptureMode::CAPTURE_MODE_NORMAL;
887 }
888
SetAppCachePath(const std::string cachePath)889 void AudioContainerClientBase::SetAppCachePath(const std::string cachePath)
890 {
891 AUDIO_INFO_LOG("AudioContainerClientBase::SetAppCachePath cachePath %{public}s", cachePath.c_str());
892 }
893 } // namespace AudioStandard
894 } // namespace OHOS
895
896