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 "hdf_audio_server_common.h"
17
18 namespace OHOS::HDI::Audio_Bluetooth {
19 const int MANAGER_ADAPTER_NAME_LEN = 32;
20
21 int32_t g_serverAdapterNum = 0;
22 struct AudioInfoInAdapter *g_renderAndCaptureManage = NULL;
23
AdapterManageInit(struct AudioInfoInAdapter * adapterManage,const char * adapterName)24 static int32_t AdapterManageInit(struct AudioInfoInAdapter *adapterManage,
25 const char *adapterName)
26 {
27 int32_t ret;
28
29 if (adapterManage == NULL || adapterName == NULL) {
30 HDF_LOGE("%{public}s: Parameter error! ", __func__);
31
32 return HDF_FAILURE;
33 }
34
35 adapterManage->adapterName = static_cast<char *>(calloc(1, MANAGER_ADAPTER_NAME_LEN));
36 if (adapterManage->adapterName == NULL) {
37 HDF_LOGE("%{public}s: calloc adapter name failed!", __func__);
38
39 return HDF_FAILURE;
40 }
41
42 ret = memcpy_s(static_cast<void *>(const_cast<char *>(adapterManage->adapterName)), MANAGER_ADAPTER_NAME_LEN,
43 adapterName, MANAGER_ADAPTER_NAME_LEN);
44 if (ret != EOK) {
45 HDF_LOGE("%{public}s: memcpy adapter name fail!", __func__);
46 AudioMemFree(reinterpret_cast<void **>(const_cast<char **>(&adapterManage->adapterName)));
47
48 return HDF_FAILURE;
49 }
50
51 adapterManage->adapter = NULL;
52 adapterManage->adapterUserNum = 0;
53 adapterManage->renderStatus = 0;
54 adapterManage->renderPriority = -1;
55 adapterManage->render = NULL;
56 adapterManage->renderBusy = false;
57 adapterManage->renderDestory = false;
58 adapterManage->renderPid = 0;
59
60 return HDF_SUCCESS;
61 }
62
ServerManageGetAdapterNum(void)63 int32_t ServerManageGetAdapterNum(void)
64 {
65 return ((g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum);
66 }
67
ServerManageGetAdapters(void)68 struct AudioInfoInAdapter *ServerManageGetAdapters(void)
69 {
70 return g_renderAndCaptureManage;
71 }
72
73
AdaptersServerManageRelease(const struct AudioInfoInAdapter * adaptersManage,int32_t num)74 void AdaptersServerManageRelease(
75 const struct AudioInfoInAdapter *adaptersManage, int32_t num)
76 {
77 int32_t i;
78
79 if (adaptersManage == NULL || num <= 0) {
80 HDF_LOGE("%{public}s: Parameter error! ", __func__);
81
82 return;
83 }
84
85 num = (num > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : num;
86 for (i = 0; i < num; i++) {
87 if (adaptersManage[i].adapterName != NULL) {
88 AudioMemFree((void **)&adaptersManage[i].adapterName);
89 }
90 }
91 AudioMemFree(reinterpret_cast<void **>(const_cast<AudioInfoInAdapter **>(&adaptersManage)));
92 }
93
AdaptersServerManageInfomationRecycle(void)94 void AdaptersServerManageInfomationRecycle(void)
95 {
96 AdaptersServerManageRelease(g_renderAndCaptureManage, g_serverAdapterNum);
97 g_renderAndCaptureManage = NULL;
98 g_serverAdapterNum = 0;
99 }
100
AdaptersServerManageInit(const struct AudioAdapterDescriptor * descs,int32_t num)101 int32_t AdaptersServerManageInit(const struct AudioAdapterDescriptor *descs, int32_t num)
102 {
103 int32_t i, ret;
104 struct AudioInfoInAdapter *adaptersManage = NULL;
105
106 if (descs == NULL || num <= 0) {
107 HDF_LOGE("%{public}s: Parameter error! ", __func__);
108
109 return HDF_FAILURE;
110 }
111
112 num = (num > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : num;
113 adaptersManage = reinterpret_cast<struct AudioInfoInAdapter *>(calloc(1, num * sizeof(struct AudioInfoInAdapter)));
114 if (adaptersManage == NULL) {
115 HDF_LOGE("%{public}s: calloc adaptersManage failed! ", __func__);
116
117 return HDF_FAILURE;
118 }
119 for (i = 0; i < num; i++) {
120 ret = AdapterManageInit(&adaptersManage[i], descs[i].adapterName);
121 if (ret != HDF_SUCCESS) {
122 AdaptersServerManageRelease(adaptersManage, num);
123
124 return ret;
125 }
126 }
127 g_serverAdapterNum = num;
128 g_renderAndCaptureManage = adaptersManage;
129
130 return HDF_SUCCESS;
131 }
132
HdiServiceRenderCaptureReadData(struct HdfSBuf * data,const char ** adapterName,uint32_t * pid)133 int32_t HdiServiceRenderCaptureReadData(struct HdfSBuf *data, const char **adapterName, uint32_t *pid)
134 {
135 if (adapterName == NULL || data == NULL || pid == NULL) {
136 return HDF_FAILURE;
137 }
138 if ((*adapterName = HdfSbufReadString(data)) == NULL) {
139 HDF_LOGE("%{public}s: adapterName Is NULL ", __func__);
140 return HDF_FAILURE;
141 }
142 if (!HdfSbufReadUint32(data, pid)) {
143 HDF_LOGE("%{public}s: read buf fail ", __func__);
144 return HDF_FAILURE;
145 }
146 return HDF_SUCCESS;
147 }
148
WriteAudioSampleAttributes(struct HdfSBuf * reply,const struct AudioSampleAttributes * attrs)149 int32_t WriteAudioSampleAttributes(struct HdfSBuf *reply, const struct AudioSampleAttributes *attrs)
150 {
151 if (reply == NULL || attrs == NULL) {
152 return HDF_FAILURE;
153 }
154 uint32_t tempAttrParam = (uint32_t)attrs->type;
155 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
156 return HDF_FAILURE;
157 }
158 tempAttrParam = (uint32_t)attrs->interleaved;
159 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
160 return HDF_FAILURE;
161 }
162 tempAttrParam = (uint32_t)attrs->format;
163 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
164 return HDF_FAILURE;
165 }
166 if (!HdfSbufWriteUint32(reply, attrs->sampleRate)) {
167 return HDF_FAILURE;
168 }
169 if (!HdfSbufWriteUint32(reply, attrs->channelCount)) {
170 return HDF_FAILURE;
171 }
172 if (!HdfSbufWriteUint32(reply, attrs->period)) {
173 return HDF_FAILURE;
174 }
175 if (!HdfSbufWriteUint32(reply, attrs->frameSize)) {
176 return HDF_FAILURE;
177 }
178 tempAttrParam = (uint32_t)(attrs->isBigEndian);
179 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
180 return HDF_FAILURE;
181 }
182 tempAttrParam = (uint32_t)(attrs->isSignedData);
183 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
184 return HDF_FAILURE;
185 }
186 if (!HdfSbufWriteUint32(reply, attrs->startThreshold)) {
187 return HDF_FAILURE;
188 }
189 if (!HdfSbufWriteUint32(reply, attrs->stopThreshold)) {
190 return HDF_FAILURE;
191 }
192 if (!HdfSbufWriteUint32(reply, attrs->silenceThreshold)) {
193 return HDF_FAILURE;
194 }
195 return HDF_SUCCESS;
196 }
197
ReadAudioSapmleAttrbutes(struct HdfSBuf * data,struct AudioSampleAttributes * attrs)198 int32_t ReadAudioSapmleAttrbutes(struct HdfSBuf *data, struct AudioSampleAttributes *attrs)
199 {
200 if (data == NULL || attrs == NULL) {
201 return HDF_FAILURE;
202 }
203 uint32_t tempAttrParam = 0;
204 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
205 return HDF_FAILURE;
206 }
207 attrs->type = (AudioCategory)tempAttrParam;
208 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
209 return HDF_FAILURE;
210 }
211 attrs->interleaved = (bool)tempAttrParam;
212 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
213 return HDF_FAILURE;
214 }
215 attrs->format = (AudioFormat)tempAttrParam;
216 if (!HdfSbufReadUint32(data, &(attrs->sampleRate))) {
217 return HDF_FAILURE;
218 }
219 if (!HdfSbufReadUint32(data, &(attrs->channelCount))) {
220 return HDF_FAILURE;
221 }
222 if (!HdfSbufReadUint32(data, &(attrs->period))) {
223 return HDF_FAILURE;
224 }
225 if (!HdfSbufReadUint32(data, &(attrs->frameSize))) {
226 return HDF_FAILURE;
227 }
228 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
229 return HDF_FAILURE;
230 }
231 attrs->isBigEndian = (bool)tempAttrParam;
232 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
233 return HDF_FAILURE;
234 }
235 attrs->isSignedData = (bool)tempAttrParam;
236 if (!HdfSbufReadUint32(data, &(attrs->startThreshold))) {
237 return HDF_FAILURE;
238 }
239 if (!HdfSbufReadUint32(data, &(attrs->stopThreshold))) {
240 return HDF_FAILURE;
241 }
242 if (!HdfSbufReadUint32(data, &(attrs->silenceThreshold))) {
243 return HDF_FAILURE;
244 }
245 return HDF_SUCCESS;
246 }
247
AudioAdapterListGetAdapter(const char * adapterName,struct AudioAdapter ** adapter)248 int32_t AudioAdapterListGetAdapter(const char *adapterName, struct AudioAdapter **adapter)
249 {
250 int32_t i, num;
251
252 LOG_FUN_INFO();
253 if (g_renderAndCaptureManage == NULL) {
254 return HDF_ERR_INVALID_PARAM;
255 }
256 if (adapterName == NULL || adapter == NULL) {
257 HDF_LOGE("%{public}s: The pointer is null ", __func__);
258 return HDF_ERR_INVALID_PARAM;
259 }
260
261 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
262 MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
263 for (i = 0; i < num; i++) {
264 if (g_renderAndCaptureManage[i].adapterName == NULL) {
265 return HDF_ERR_INVALID_PARAM;
266 }
267 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
268 *adapter = g_renderAndCaptureManage[i].adapter;
269 return HDF_SUCCESS;
270 }
271 }
272 return HDF_ERR_INVALID_PARAM;
273 }
274
AudioDestroyFormerRender(struct AudioInfoInAdapter * renderManage)275 int32_t AudioDestroyFormerRender(struct AudioInfoInAdapter *renderManage)
276 {
277 LOG_FUN_INFO();
278 if (renderManage == NULL || renderManage->adapter == NULL || renderManage->render == NULL) {
279 HDF_LOGE("%{public}s: input para is NULL. ", __func__);
280 return HDF_FAILURE;
281 }
282 int count = 0;
283 renderManage->renderDestory = true;
284 while (renderManage->renderBusy) {
285 if (count > 1000) { // Less than 1000
286 HDF_LOGE("%{public}s: , count = %{public}d", __func__, count);
287 renderManage->renderDestory = false;
288 return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
289 }
290 usleep(500); // sleep 500us
291 count++;
292 }
293 renderManage->renderPid = 0;
294 if (renderManage->adapter->DestroyRender(renderManage->adapter, renderManage->render)) {
295 renderManage->renderDestory = false;
296 return HDF_FAILURE;
297 }
298 renderManage->render = NULL;
299 renderManage->renderStatus = 0;
300 renderManage->renderBusy = false;
301 renderManage->renderDestory = false;
302 renderManage->renderPriority = -1;
303 return HDF_SUCCESS;
304 }
305
AudioDestroyFormerCapture(struct AudioInfoInAdapter * captureManage)306 int32_t AudioDestroyFormerCapture(struct AudioInfoInAdapter *captureManage)
307 {
308 LOG_FUN_INFO();
309 if (captureManage == nullptr || captureManage->adapter == nullptr || captureManage->capture == nullptr) {
310 HDF_LOGE("%{public}s: input para is NULL. ", __func__);
311 return HDF_FAILURE;
312 }
313 int count = 0;
314 captureManage->captureDestroy = true;
315 while (captureManage->captureBusy) {
316 if (count > 1000) { // Less than 1000
317 HDF_LOGE("%{public}s: , count = %{public}d", __func__, count);
318 captureManage->captureDestroy = false;
319 return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
320 }
321 usleep(500); // sleep 500us
322 count++;
323 }
324 captureManage->capturePid = 0;
325 if (captureManage->adapter->DestroyCapture(captureManage->adapter, captureManage->capture)) {
326 captureManage->captureDestroy = false;
327 return HDF_FAILURE;
328 }
329 captureManage->capture = nullptr;
330 captureManage->captureStatus = 0;
331 captureManage->captureBusy = false;
332 captureManage->captureDestroy = false;
333 captureManage->capturePriority = -1;
334 return HDF_SUCCESS;
335 }
336
AudioJudgeRenderPriority(const int32_t priority,int which)337 int32_t AudioJudgeRenderPriority(const int32_t priority, int which)
338 {
339 int32_t num;
340
341 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
342 if (which < 0 || which >= num) {
343 HDF_LOGE("%{public}s: invalid value! ", __func__);
344 return HDF_FAILURE;
345 }
346 if (g_renderAndCaptureManage == NULL) {
347 return HDF_FAILURE;
348 }
349 if (g_renderAndCaptureManage[which].renderPriority <= priority) {
350 if (AudioDestroyFormerRender(&g_renderAndCaptureManage[which])) {
351 HDF_LOGE("%{public}s: AudioDestroyFormerRender: Fail. ", __func__);
352 return HDF_FAILURE;
353 }
354 return HDF_SUCCESS;
355 } else {
356 return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
357 }
358 return HDF_FAILURE;
359 }
360
AudioJudgeCapturePriority(const int32_t priority,int which)361 int32_t AudioJudgeCapturePriority(const int32_t priority, int which)
362 {
363 int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER)
364 ? MAX_AUDIO_ADAPTER_NUM_SERVER
365 : g_serverAdapterNum;
366 if (which < 0 || which >= num) {
367 HDF_LOGE("%{public}s: invalid value! ", __func__);
368 return HDF_FAILURE;
369 }
370 if (g_renderAndCaptureManage == nullptr) {
371 return HDF_FAILURE;
372 }
373 if (g_renderAndCaptureManage[which].capturePriority <= priority) {
374 if (AudioDestroyFormerCapture(&g_renderAndCaptureManage[which])) {
375 HDF_LOGE("%{public}s: AudioDestroyFormerCapture: Fail. ", __func__);
376 return HDF_FAILURE;
377 }
378 return HDF_SUCCESS;
379 } else {
380 return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
381 }
382 return HDF_FAILURE;
383 }
384
AudioCreatRenderCheck(const char * adapterName,const int32_t priority)385 int32_t AudioCreatRenderCheck(const char *adapterName, const int32_t priority)
386 {
387 int32_t i;
388
389 LOG_FUN_INFO();
390 if (adapterName == NULL || g_renderAndCaptureManage == NULL) {
391 return HDF_FAILURE;
392 }
393
394 int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER)
395 ? MAX_AUDIO_ADAPTER_NUM_SERVER
396 : g_serverAdapterNum;
397 for (i = 0; i < num; i++) {
398 if (g_renderAndCaptureManage[i].adapterName == NULL) {
399 return HDF_FAILURE;
400 }
401 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
402 if (!(g_renderAndCaptureManage[i].renderStatus)) {
403 return HDF_SUCCESS;
404 } else {
405 return AudioJudgeRenderPriority(priority, i);
406 }
407 }
408 }
409 HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
410 return HDF_FAILURE;
411 }
412
AudioCreateCaptureCheck(const char * adapterName,const int32_t priority)413 int32_t AudioCreateCaptureCheck(const char *adapterName, const int32_t priority)
414 {
415 int32_t i;
416 LOG_FUN_INFO();
417 if (adapterName == nullptr || g_renderAndCaptureManage == nullptr) {
418 return HDF_FAILURE;
419 }
420 int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER)
421 ? MAX_AUDIO_ADAPTER_NUM_SERVER
422 : g_serverAdapterNum;
423 for (i = 0; i < num; i++) {
424 if (g_renderAndCaptureManage[i].adapterName == nullptr) {
425 return HDF_FAILURE;
426 }
427 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
428 if (!(g_renderAndCaptureManage[i].captureStatus)) {
429 return HDF_SUCCESS;
430 } else {
431 return AudioJudgeCapturePriority(priority, i);
432 }
433 }
434 }
435 HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
436 return HDF_FAILURE;
437 }
438
AudioAddRenderInfoInAdapter(const char * adapterName,struct AudioRender * render,const struct AudioAdapter * adapter,const int32_t priority,uint32_t renderPid)439 int32_t AudioAddRenderInfoInAdapter(const char *adapterName,
440 struct AudioRender *render,
441 const struct AudioAdapter *adapter,
442 const int32_t priority,
443 uint32_t renderPid)
444 {
445 int32_t i, num;
446
447 if (adapterName == NULL || adapter == NULL || render == NULL) {
448 HDF_LOGE("%{public}s: input para is NULL. ", __func__);
449 return HDF_FAILURE;
450 }
451 if (g_renderAndCaptureManage == NULL) {
452 return HDF_FAILURE;
453 }
454 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
455 for (i = 0; i < num; i++) {
456 if (g_renderAndCaptureManage[i].adapterName == NULL) {
457 return HDF_FAILURE;
458 }
459 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
460 g_renderAndCaptureManage[i].renderStatus = 1;
461 g_renderAndCaptureManage[i].renderPriority = priority;
462 g_renderAndCaptureManage[i].render = render;
463 g_renderAndCaptureManage[i].renderPid = renderPid;
464 return HDF_SUCCESS;
465 }
466 }
467 HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
468 return HDF_FAILURE;
469 }
470
AudioAddCaptureInfoInAdapter(const char * adapterName,struct AudioCapture * capture,const struct AudioAdapter * adapter,const int32_t priority,uint32_t capturePid)471 int32_t AudioAddCaptureInfoInAdapter(const char *adapterName, struct AudioCapture *capture,
472 const struct AudioAdapter *adapter, const int32_t priority, uint32_t capturePid)
473 {
474 int32_t i;
475 int32_t num;
476 if (adapterName == nullptr || adapter == nullptr || capture == nullptr) {
477 HDF_LOGE("%{public}s: input para is NULL. ", __func__);
478 return HDF_FAILURE;
479 }
480 if (g_renderAndCaptureManage == nullptr) {
481 return HDF_FAILURE;
482 }
483 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
484 for (i = 0; i < num; i++) {
485 if (g_renderAndCaptureManage[i].adapterName == nullptr) {
486 return HDF_FAILURE;
487 }
488 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
489 g_renderAndCaptureManage[i].captureStatus = 1;
490 g_renderAndCaptureManage[i].capturePriority = priority;
491 g_renderAndCaptureManage[i].capture = capture;
492 g_renderAndCaptureManage[i].capturePid = capturePid;
493 return HDF_SUCCESS;
494 }
495 }
496 HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
497 return HDF_FAILURE;
498 }
499
AudioSetRenderStatus(const char * adapterName,bool renderStatus)500 void AudioSetRenderStatus(const char *adapterName, bool renderStatus)
501 {
502 int32_t i, num;
503 if (g_renderAndCaptureManage == NULL) {
504 return;
505 }
506 LOG_FUN_INFO();
507 if (adapterName == NULL) {
508 HDF_LOGE("%{public}s: adapterName is null ", __func__);
509 return;
510 }
511
512 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
513 for (i = 0; i < num; i++) {
514 if (g_renderAndCaptureManage[i].adapterName == NULL) {
515 return;
516 }
517 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
518 g_renderAndCaptureManage[i].renderBusy = renderStatus;
519 return;
520 }
521 }
522 HDF_LOGE("%{public}s: AudioDestroyRenderInfoInAdapter: Can not find Adapter! ", __func__);
523 return;
524 }
525
AudioGetRenderStatus(const char * adapterName)526 int32_t AudioGetRenderStatus(const char *adapterName)
527 {
528 int32_t i;
529 int32_t num;
530 LOG_FUN_INFO();
531 if (adapterName == NULL || g_renderAndCaptureManage == NULL) {
532 return HDF_FAILURE;
533 }
534
535 num = (g_serverAdapterNum >
536 MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
537 for (i = 0; i < num; i++) {
538 if (g_renderAndCaptureManage[i].adapterName == NULL) {
539 return HDF_FAILURE;
540 }
541 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
542 if (!g_renderAndCaptureManage[i].renderDestory) {
543 return HDF_SUCCESS;
544 } else {
545 g_renderAndCaptureManage[i].renderBusy = false;
546 return HDF_FAILURE;
547 }
548 }
549 }
550 HDF_LOGE("%{public}s: AudioDestroyRenderInfoInAdapter: Can not find Adapter! ", __func__);
551 return HDF_FAILURE;
552 }
553
AudioDestroyRenderInfoInAdapter(const char * adapterName)554 int32_t AudioDestroyRenderInfoInAdapter(const char *adapterName)
555 {
556 int32_t i, num;
557
558 LOG_FUN_INFO();
559 if (adapterName == NULL) {
560 HDF_LOGE("%{public}s: adapterName is null ", __func__);
561 return HDF_FAILURE;
562 }
563
564 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
565 if (g_renderAndCaptureManage == NULL) {
566 return HDF_FAILURE;
567 }
568 for (i = 0; i < num; i++) {
569 if (g_renderAndCaptureManage[i].adapterName == NULL) {
570 return HDF_FAILURE;
571 }
572 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
573 g_renderAndCaptureManage[i].renderStatus = 0;
574 g_renderAndCaptureManage[i].renderPriority = -1;
575 g_renderAndCaptureManage[i].render = NULL;
576 g_renderAndCaptureManage[i].renderPid = 0;
577 return HDF_SUCCESS;
578 }
579 }
580 HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
581 return HDF_FAILURE;
582 }
583
AudioDestroyCaptureInfoInAdapter(const char * adapterName)584 int32_t AudioDestroyCaptureInfoInAdapter(const char *adapterName)
585 {
586 int32_t i;
587 int32_t num;
588 LOG_FUN_INFO();
589 if (adapterName == nullptr) {
590 HDF_LOGE("%{public}s: adapterName is null ", __func__);
591 return HDF_FAILURE;
592 }
593 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
594 if (g_renderAndCaptureManage == nullptr) {
595 return HDF_FAILURE;
596 }
597 for (i = 0; i < num; i++) {
598 if (g_renderAndCaptureManage[i].adapterName == nullptr) {
599 return HDF_FAILURE;
600 }
601 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
602 g_renderAndCaptureManage[i].captureStatus = 0;
603 g_renderAndCaptureManage[i].capturePriority = -1;
604 g_renderAndCaptureManage[i].capture = nullptr;
605 g_renderAndCaptureManage[i].capturePid = 0;
606 return HDF_SUCCESS;
607 }
608 }
609 HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
610 return HDF_FAILURE;
611 }
612
AudioAdapterListGetPid(const char * adapterName,uint32_t * pid)613 int32_t AudioAdapterListGetPid(const char *adapterName, uint32_t *pid)
614 {
615 LOG_FUN_INFO();
616 int32_t i, num;
617 if (g_renderAndCaptureManage == NULL) {
618 return HDF_ERR_INVALID_PARAM;
619 }
620 if (adapterName == NULL || pid == NULL) {
621 HDF_LOGE("%{public}s: The pointer is null ", __func__);
622 return HDF_ERR_INVALID_PARAM;
623 }
624 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
625 for (i = 0; i < num; i++) {
626 if (g_renderAndCaptureManage[i].adapterName == NULL) {
627 return HDF_ERR_INVALID_PARAM;
628 }
629 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
630 HDF_LOGE("%{public}s: i = %{public}d", __func__, i);
631 *pid = g_renderAndCaptureManage[i].renderPid;
632 HDF_LOGE("%{public}s: pid = %{public}u", __func__, *pid);
633 return HDF_SUCCESS;
634 }
635 }
636 return HDF_ERR_INVALID_PARAM;
637 }
638
AudioAdapterListGetAdapterRender(const char * adapterName,struct AudioAdapter ** adapter,struct AudioRender ** render)639 int32_t AudioAdapterListGetAdapterRender(const char *adapterName,
640 struct AudioAdapter **adapter, struct AudioRender **render)
641 {
642 int32_t i, num;
643
644 LOG_FUN_INFO();
645 if (g_renderAndCaptureManage == NULL) {
646 return HDF_ERR_INVALID_PARAM;
647 }
648 if (adapterName == NULL || adapter == NULL || render == NULL) {
649 HDF_LOGE("%{public}s: The pointer is null ", __func__);
650 return HDF_ERR_INVALID_PARAM;
651 }
652
653 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
654 for (i = 0; i < num; i++) {
655 if (g_renderAndCaptureManage[i].adapterName == NULL) {
656 return HDF_ERR_INVALID_PARAM;
657 }
658 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
659 *adapter = g_renderAndCaptureManage[i].adapter;
660 *render = g_renderAndCaptureManage[i].render;
661 return HDF_SUCCESS;
662 }
663 }
664 return HDF_ERR_INVALID_PARAM;
665 }
666
AudioAdapterListGetAdapterCapture(const char * adapterName,struct AudioAdapter ** adapter,struct AudioCapture ** capture)667 int32_t AudioAdapterListGetAdapterCapture(const char *adapterName,
668 struct AudioAdapter **adapter, struct AudioCapture **capture)
669 {
670 int32_t i;
671 int32_t num;
672 LOG_FUN_INFO();
673 if (g_renderAndCaptureManage == nullptr) {
674 return HDF_ERR_INVALID_PARAM;
675 }
676 if (adapterName == nullptr || adapter == nullptr || capture == nullptr) {
677 HDF_LOGE("%{public}s: The pointer is null ", __func__);
678 return HDF_ERR_INVALID_PARAM;
679 }
680
681 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
682 for (i = 0; i < num; i++) {
683 if (g_renderAndCaptureManage[i].adapterName == nullptr) {
684 return HDF_ERR_INVALID_PARAM;
685 }
686 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
687 *adapter = g_renderAndCaptureManage[i].adapter;
688 *capture = g_renderAndCaptureManage[i].capture;
689 return HDF_SUCCESS;
690 }
691 }
692 return HDF_ERR_INVALID_PARAM;
693 }
694
AudioAdapterListGetRender(const char * adapterName,struct AudioRender ** render,uint32_t pid)695 int32_t AudioAdapterListGetRender(const char *adapterName, struct AudioRender **render, uint32_t pid)
696 {
697 int32_t num;
698
699 HDF_LOGD("%{public}s: enter ", __func__);
700 if (g_renderAndCaptureManage == NULL) {
701 return HDF_ERR_INVALID_PARAM;
702 }
703 if (adapterName == NULL || render == NULL) {
704 HDF_LOGE("%{public}s: pointer is null ", __func__);
705 return HDF_ERR_INVALID_PARAM;
706 }
707 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
708 for (int32_t i = 0; i < num; i++) {
709 if (g_renderAndCaptureManage[i].adapterName == NULL) {
710 return HDF_ERR_INVALID_PARAM;
711 }
712 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
713 if (g_renderAndCaptureManage[i].renderPid != pid) {
714 HDF_LOGE("%{public}s: renderPid != pid renderPid = %{public}u, pid = %{public}u",
715 __func__, g_renderAndCaptureManage[i].renderPid, pid);
716 return AUDIO_HAL_ERR_INVALID_OBJECT;
717 }
718 *render = g_renderAndCaptureManage[i].render;
719 return HDF_SUCCESS;
720 }
721 }
722 return HDF_ERR_INVALID_PARAM;
723 }
724
AudioAdapterListGetCapture(const char * adapterName,struct AudioCapture ** capture,uint32_t pid)725 int32_t AudioAdapterListGetCapture(const char *adapterName, struct AudioCapture **capture, uint32_t pid)
726 {
727 int32_t num;
728 HDF_LOGD("%{public}s: enter ", __func__);
729 if (g_renderAndCaptureManage == nullptr) {
730 return HDF_ERR_INVALID_PARAM;
731 }
732 if (adapterName == nullptr || capture == nullptr) {
733 HDF_LOGE("%{public}s: pointer is null ", __func__);
734 return HDF_ERR_INVALID_PARAM;
735 }
736 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
737 for (int32_t i = 0; i < num; i++) {
738 if (g_renderAndCaptureManage[i].adapterName == nullptr) {
739 return HDF_ERR_INVALID_PARAM;
740 }
741 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
742 if (g_renderAndCaptureManage[i].capturePid != pid) {
743 HDF_LOGE("%{public}s: renderPid != pid renderPid = %{public}u, pid = %{public}u",
744 __func__, g_renderAndCaptureManage[i].capturePid, pid);
745 return AUDIO_HAL_ERR_INVALID_OBJECT;
746 }
747 *capture = g_renderAndCaptureManage[i].capture;
748 return HDF_SUCCESS;
749 }
750 }
751 return HDF_ERR_INVALID_PARAM;
752 }
753
AudioAdapterFrameGetCapture(const char * adapterName,struct AudioCapture ** capture,uint32_t pid,uint32_t * index)754 int32_t AudioAdapterFrameGetCapture(const char *adapterName, struct AudioCapture **capture, uint32_t pid,
755 uint32_t *index)
756 {
757 if (adapterName == nullptr || capture == nullptr || index == nullptr) {
758 HDF_LOGE("adapterName or capture or index is null");
759 return HDF_ERR_INVALID_PARAM;
760 }
761 int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER)
762 ? MAX_AUDIO_ADAPTER_NUM_SERVER
763 : g_serverAdapterNum;
764 *index = MAX_AUDIO_ADAPTER_NUM_SERVER;
765 for (int32_t i = 0; i < num; i++) {
766 if (g_renderAndCaptureManage[i].adapterName == nullptr) {
767 HDF_LOGE("g_renderAndCaptureManage[%{public}d] adapterName is null!", i);
768 return HDF_ERR_INVALID_PARAM;
769 }
770 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
771 if (g_renderAndCaptureManage[i].capturePid != pid) {
772 HDF_LOGE("%{public}s: capturePid != pid capturePid = %{public}u, pid = %{public}u",
773 __func__, g_renderAndCaptureManage[i].capturePid, pid);
774 return AUDIO_HAL_ERR_INVALID_OBJECT;
775 }
776 if (!g_renderAndCaptureManage[i].captureDestroy) {
777 *capture = g_renderAndCaptureManage[i].capture;
778 *index = i;
779 return HDF_SUCCESS;
780 } else {
781 g_renderAndCaptureManage[i].captureBusy = false;
782 HDF_LOGE("g_renderAndCaptureManage[%{public}d] captureBusy is false!", i);
783 return HDF_FAILURE;
784 }
785 }
786 }
787 HDF_LOGE("AudioAdapterFrameGetCapture failed!");
788 return HDF_FAILURE;
789 }
790
AudioAdapterListCheckAndGetRender(struct AudioRender ** render,struct HdfSBuf * data)791 int32_t AudioAdapterListCheckAndGetRender(struct AudioRender **render, struct HdfSBuf *data)
792 {
793 if (render == NULL || data == NULL) {
794 return HDF_FAILURE;
795 }
796 struct AudioRender *renderTemp = NULL;
797 const char *adapterName = NULL;
798 uint32_t pid = 0;
799 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
800 HDF_LOGE("%{public}s: HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail ", __func__);
801 return HDF_FAILURE;
802 }
803 int ret = AudioAdapterListGetRender(adapterName, &renderTemp, pid);
804 if (ret < 0) {
805 return ret;
806 }
807 if (renderTemp == NULL) {
808 return HDF_FAILURE;
809 }
810 *render = renderTemp;
811 return HDF_SUCCESS;
812 }
813
AudioAdapterListCheckAndGetCapture(struct AudioCapture ** capture,struct HdfSBuf * data)814 int32_t AudioAdapterListCheckAndGetCapture(struct AudioCapture **capture, struct HdfSBuf *data)
815 {
816 if (capture == nullptr || data == nullptr) {
817 return HDF_FAILURE;
818 }
819 struct AudioCapture *captureTemp = nullptr;
820 const char *adapterName = nullptr;
821 uint32_t pid = 0;
822 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
823 HDF_LOGE("%{public}s: HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail ", __func__);
824 return HDF_FAILURE;
825 }
826 int ret = AudioAdapterListGetCapture(adapterName, &captureTemp, pid);
827 if (ret < 0) {
828 return ret;
829 }
830 if (captureTemp == nullptr) {
831 return HDF_FAILURE;
832 }
833 *capture = captureTemp;
834 return HDF_SUCCESS;
835 }
836
AudioAdapterCheckListExist(const char * adapterName)837 int32_t AudioAdapterCheckListExist(const char *adapterName)
838 {
839 int32_t i, num;
840
841 LOG_FUN_INFO();
842 if (g_renderAndCaptureManage == NULL) {
843 return AUDIO_HAL_ERR_INVALID_PARAM;
844 }
845 if (adapterName == NULL) {
846 HDF_LOGE("%{public}s: The pointer is null. ", __func__);
847 return AUDIO_HAL_ERR_INVALID_PARAM;
848 }
849
850 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
851 for (i = 0; i < num; i++) {
852 if (g_renderAndCaptureManage[i].adapterName == NULL) {
853 return AUDIO_HAL_ERR_INVALID_PARAM;
854 }
855 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
856 if (g_renderAndCaptureManage[i].adapterUserNum == 0) {
857 return AUDIO_HAL_ERR_INTERNAL;
858 } else if (g_renderAndCaptureManage[i].adapterUserNum > 0) {
859 g_renderAndCaptureManage[i].adapterUserNum++;
860 return AUDIO_HAL_SUCCESS;
861 }
862 }
863 }
864 return AUDIO_HAL_ERR_INVALID_PARAM;
865 }
866
AudioAdapterListDestory(const char * adapterName,struct AudioAdapter ** adapter)867 int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **adapter)
868 {
869 int32_t i, num;
870 if (adapter == NULL) {
871 return AUDIO_HAL_ERR_INVALID_PARAM;
872 }
873 LOG_FUN_INFO();
874 if (adapterName == NULL) {
875 HDF_LOGE("%{public}s: adapterName is NULL. ", __func__);
876 return AUDIO_HAL_ERR_INVALID_PARAM;
877 }
878 if (g_renderAndCaptureManage == NULL) {
879 return AUDIO_HAL_ERR_INVALID_PARAM;
880 }
881 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
882 for (i = 0; i < num; i++) {
883 if (g_renderAndCaptureManage[i].adapterName == NULL) {
884 return AUDIO_HAL_ERR_INVALID_PARAM;
885 }
886 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
887 if (g_renderAndCaptureManage[i].adapterUserNum == 1) {
888 g_renderAndCaptureManage[i].adapterUserNum--;
889 *adapter = g_renderAndCaptureManage[i].adapter;
890 g_renderAndCaptureManage[i].adapter = NULL;
891 return AUDIO_HAL_SUCCESS;
892 } else if (g_renderAndCaptureManage[i].adapterUserNum > 1) {
893 g_renderAndCaptureManage[i].adapterUserNum--;
894 return AUDIO_HAL_ERR_INTERNAL;
895 }
896 }
897 }
898 return AUDIO_HAL_ERR_INVALID_PARAM;
899 }
900
AudioAdapterListAdd(const char * adapterName,struct AudioAdapter * adapter)901 int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapter)
902 {
903 int32_t i, num;
904
905 LOG_FUN_INFO();
906 if (adapterName == NULL || adapter == NULL) {
907 HDF_LOGE("%{public}s: adapterName is NULL. ", __func__);
908 return HDF_ERR_INVALID_PARAM;
909 }
910 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
911 MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
912 if (g_renderAndCaptureManage == NULL) {
913 return HDF_ERR_INVALID_PARAM;
914 }
915 for (i = 0; i < num; i++) {
916 if (g_renderAndCaptureManage[i].adapterName == NULL) {
917 return HDF_ERR_INVALID_PARAM;
918 }
919 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
920 g_renderAndCaptureManage[i].adapter = adapter;
921 g_renderAndCaptureManage[i].adapterUserNum = 1;
922 return HDF_SUCCESS;
923 }
924 }
925 return HDF_ERR_INVALID_PARAM;
926 }
927
HdiServicePositionWrite(struct HdfSBuf * reply,uint64_t frames,struct AudioTimeStamp time)928 int32_t HdiServicePositionWrite(struct HdfSBuf *reply,
929 uint64_t frames, struct AudioTimeStamp time)
930 {
931 if (reply == NULL) {
932 return HDF_FAILURE;
933 }
934 if (!HdfSbufWriteUint64(reply, frames)) {
935 return HDF_FAILURE;
936 }
937 if (!HdfSbufWriteInt64(reply, time.tvSec)) {
938 return HDF_FAILURE;
939 }
940 if (!HdfSbufWriteInt64(reply, time.tvNSec)) {
941 return HDF_FAILURE;
942 }
943 return HDF_SUCCESS;
944 }
945
HdiServiceReqMmapBuffer(struct AudioMmapBufferDescriptor * desc,struct HdfSBuf * data)946 int32_t HdiServiceReqMmapBuffer(struct AudioMmapBufferDescriptor *desc, struct HdfSBuf *data)
947 {
948 int32_t ret;
949 if (desc == NULL || data == NULL) {
950 return AUDIO_HAL_ERR_INTERNAL;
951 }
952 uint64_t memAddr = 0;
953 if (!HdfSbufReadUint64(data, &memAddr)) {
954 HDF_LOGE("%{public}s: memAddr Is NULL", __func__);
955 return AUDIO_HAL_ERR_INTERNAL;
956 }
957 desc->memoryAddress = reinterpret_cast<void *>((uintptr_t)memAddr);
958 ret = HdfSbufReadFileDescriptor(data);
959 if (ret < 0) {
960 return HDF_FAILURE;
961 }
962 desc->memoryFd = ret;
963 if (!HdfSbufReadInt32(data, &desc->totalBufferFrames)) {
964 return AUDIO_HAL_ERR_INTERNAL;
965 }
966 if (!HdfSbufReadInt32(data, &desc->transferFrameSize)) {
967 return AUDIO_HAL_ERR_INTERNAL;
968 }
969 if (!HdfSbufReadInt32(data, &desc->isShareable)) {
970 return AUDIO_HAL_ERR_INTERNAL;
971 }
972 if (!HdfSbufReadUint32(data, &desc->offset)) {
973 return AUDIO_HAL_ERR_INTERNAL;
974 }
975 return AUDIO_HAL_SUCCESS;
976 }
977
AudioSetCaptureBusy(uint32_t index,bool captureStatus)978 void AudioSetCaptureBusy(uint32_t index, bool captureStatus)
979 {
980 if (index == MAX_AUDIO_ADAPTER_NUM_SERVER) {
981 g_renderAndCaptureManage[index].captureBusy = captureStatus;
982 }
983 }
984 }