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