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 
AudioJudgeRenderPriority(const int32_t priority,int which)306 int32_t AudioJudgeRenderPriority(const int32_t priority, int which)
307 {
308     int32_t num;
309 
310     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
311     if (which < 0 || which >= num) {
312         HDF_LOGE("%{public}s: invalid value! ", __func__);
313         return HDF_FAILURE;
314     }
315     if (g_renderAndCaptureManage == NULL) {
316         return HDF_FAILURE;
317     }
318     if (g_renderAndCaptureManage[which].renderPriority <= priority) {
319         if (AudioDestroyFormerRender(&g_renderAndCaptureManage[which])) {
320             HDF_LOGE("%{public}s: AudioDestroyFormerRender: Fail. ", __func__);
321             return HDF_FAILURE;
322         }
323         return HDF_SUCCESS;
324     } else {
325         return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
326     }
327     return HDF_FAILURE;
328 }
329 
AudioCreatRenderCheck(const char * adapterName,const int32_t priority)330 int32_t AudioCreatRenderCheck(const char *adapterName, const int32_t priority)
331 {
332     int32_t i;
333 
334     LOG_FUN_INFO();
335     if (adapterName == NULL || g_renderAndCaptureManage == NULL) {
336         return HDF_FAILURE;
337     }
338 
339     int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
340         MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
341     for (i = 0; i < num; i++) {
342         if (g_renderAndCaptureManage[i].adapterName == NULL) {
343             return HDF_FAILURE;
344         }
345         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
346             if (!(g_renderAndCaptureManage[i].renderStatus)) {
347                 return HDF_SUCCESS;
348             } else {
349                 return AudioJudgeRenderPriority(priority, i);
350             }
351         }
352     }
353     HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
354     return HDF_FAILURE;
355 }
356 
AudioAddRenderInfoInAdapter(const char * adapterName,struct AudioRender * render,const struct AudioAdapter * adapter,const int32_t priority,uint32_t renderPid)357 int32_t AudioAddRenderInfoInAdapter(const char *adapterName,
358     struct AudioRender *render,
359     const struct AudioAdapter *adapter,
360     const int32_t priority,
361     uint32_t renderPid)
362 {
363     int32_t i, num;
364 
365     if (adapterName == NULL || adapter == NULL || render == NULL) {
366         HDF_LOGE("%{public}s: input para is NULL. ", __func__);
367         return HDF_FAILURE;
368     }
369     if (g_renderAndCaptureManage == NULL) {
370         return HDF_FAILURE;
371     }
372     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
373     for (i = 0; i < num; i++) {
374         if (g_renderAndCaptureManage[i].adapterName == NULL) {
375             return HDF_FAILURE;
376         }
377         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
378             g_renderAndCaptureManage[i].renderStatus = 1;
379             g_renderAndCaptureManage[i].renderPriority = priority;
380             g_renderAndCaptureManage[i].render = render;
381             g_renderAndCaptureManage[i].renderPid = renderPid;
382             return HDF_SUCCESS;
383         }
384     }
385     HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
386     return HDF_FAILURE;
387 }
388 
AudioSetRenderStatus(const char * adapterName,bool renderStatus)389 void AudioSetRenderStatus(const char *adapterName, bool renderStatus)
390 {
391     int32_t i, num;
392     if (g_renderAndCaptureManage == NULL) {
393         return;
394     }
395     LOG_FUN_INFO();
396     if (adapterName == NULL) {
397         HDF_LOGE("%{public}s: adapterName is null ", __func__);
398         return;
399     }
400 
401     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
402     for (i = 0; i < num; i++) {
403         if (g_renderAndCaptureManage[i].adapterName == NULL) {
404             return;
405         }
406         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
407             g_renderAndCaptureManage[i].renderBusy = renderStatus;
408             return;
409         }
410     }
411     HDF_LOGE("%{public}s: AudioDestroyRenderInfoInAdapter: Can not find Adapter! ", __func__);
412     return;
413 }
414 
AudioGetRenderStatus(const char * adapterName)415 int32_t AudioGetRenderStatus(const char *adapterName)
416 {
417     int32_t i;
418     int32_t num;
419     LOG_FUN_INFO();
420     if (adapterName == NULL || g_renderAndCaptureManage == NULL) {
421         return HDF_FAILURE;
422     }
423 
424     num = (g_serverAdapterNum >
425         MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
426     for (i = 0; i < num; i++) {
427         if (g_renderAndCaptureManage[i].adapterName == NULL) {
428             return HDF_FAILURE;
429         }
430         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
431             if (!g_renderAndCaptureManage[i].renderDestory) {
432                 return HDF_SUCCESS;
433             } else {
434                 g_renderAndCaptureManage[i].renderBusy = false;
435                 return HDF_FAILURE;
436             }
437         }
438     }
439     HDF_LOGE("%{public}s: AudioDestroyRenderInfoInAdapter: Can not find Adapter! ", __func__);
440     return HDF_FAILURE;
441 }
442 
AudioDestroyRenderInfoInAdapter(const char * adapterName)443 int32_t AudioDestroyRenderInfoInAdapter(const char *adapterName)
444 {
445     int32_t i, num;
446 
447     LOG_FUN_INFO();
448     if (adapterName == NULL) {
449         HDF_LOGE("%{public}s: adapterName is null ", __func__);
450         return HDF_FAILURE;
451     }
452 
453     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
454     if (g_renderAndCaptureManage == NULL) {
455         return HDF_FAILURE;
456     }
457     for (i = 0; i < num; i++) {
458         if (g_renderAndCaptureManage[i].adapterName == NULL) {
459             return HDF_FAILURE;
460         }
461         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
462             g_renderAndCaptureManage[i].renderStatus = 0;
463             g_renderAndCaptureManage[i].renderPriority = -1;
464             g_renderAndCaptureManage[i].render = NULL;
465             g_renderAndCaptureManage[i].renderPid = 0;
466             return HDF_SUCCESS;
467         }
468     }
469     HDF_LOGE("%{public}s: Can not find Adapter! ", __func__);
470     return HDF_FAILURE;
471 }
472 
AudioAdapterListGetPid(const char * adapterName,uint32_t * pid)473 int32_t AudioAdapterListGetPid(const char *adapterName, uint32_t *pid)
474 {
475     LOG_FUN_INFO();
476     int32_t i, num;
477     if (g_renderAndCaptureManage == NULL) {
478         return HDF_ERR_INVALID_PARAM;
479     }
480     if (adapterName == NULL || pid == NULL) {
481         HDF_LOGE("%{public}s: The pointer is null ", __func__);
482         return HDF_ERR_INVALID_PARAM;
483     }
484     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
485     for (i = 0; i < num; i++) {
486         if (g_renderAndCaptureManage[i].adapterName == NULL) {
487             return HDF_ERR_INVALID_PARAM;
488         }
489         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
490             HDF_LOGE("%{public}s: i = %{public}d", __func__, i);
491             *pid = g_renderAndCaptureManage[i].renderPid;
492             HDF_LOGE("%{public}s: pid = %{public}u", __func__, *pid);
493             return HDF_SUCCESS;
494         }
495     }
496     return HDF_ERR_INVALID_PARAM;
497 }
498 
AudioAdapterListGetAdapterRender(const char * adapterName,struct AudioAdapter ** adapter,struct AudioRender ** render)499 int32_t AudioAdapterListGetAdapterRender(const char *adapterName,
500     struct AudioAdapter **adapter, struct AudioRender **render)
501 {
502     int32_t i, num;
503 
504     LOG_FUN_INFO();
505     if (g_renderAndCaptureManage == NULL) {
506         return HDF_ERR_INVALID_PARAM;
507     }
508     if (adapterName == NULL || adapter == NULL || render == NULL) {
509         HDF_LOGE("%{public}s: The pointer is null ", __func__);
510         return HDF_ERR_INVALID_PARAM;
511     }
512 
513     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
514     for (i = 0; i < num; i++) {
515         if (g_renderAndCaptureManage[i].adapterName == NULL) {
516             return HDF_ERR_INVALID_PARAM;
517         }
518         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
519             *adapter = g_renderAndCaptureManage[i].adapter;
520             *render = g_renderAndCaptureManage[i].render;
521             return HDF_SUCCESS;
522         }
523     }
524     return HDF_ERR_INVALID_PARAM;
525 }
526 
AudioAdapterListGetRender(const char * adapterName,struct AudioRender ** render,uint32_t pid)527 int32_t AudioAdapterListGetRender(const char *adapterName, struct AudioRender **render, uint32_t pid)
528 {
529     int32_t num;
530 
531     HDF_LOGD("%{public}s: enter ", __func__);
532     if (g_renderAndCaptureManage == NULL) {
533         return HDF_ERR_INVALID_PARAM;
534     }
535     if (adapterName == NULL || render == NULL) {
536         HDF_LOGE("%{public}s: pointer is null ", __func__);
537         return HDF_ERR_INVALID_PARAM;
538     }
539     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
540     for (int32_t i = 0; i < num; i++) {
541         if (g_renderAndCaptureManage[i].adapterName == NULL) {
542             return HDF_ERR_INVALID_PARAM;
543         }
544         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
545             if (g_renderAndCaptureManage[i].renderPid != pid) {
546                 HDF_LOGE("%{public}s: renderPid != pid renderPid = %{public}u, pid = %{public}u",
547                     __func__, g_renderAndCaptureManage[i].renderPid, pid);
548                 return AUDIO_HAL_ERR_INVALID_OBJECT;
549             }
550             *render = g_renderAndCaptureManage[i].render;
551             return HDF_SUCCESS;
552         }
553     }
554     return HDF_ERR_INVALID_PARAM;
555 }
556 
AudioAdapterListCheckAndGetRender(struct AudioRender ** render,struct HdfSBuf * data)557 int32_t AudioAdapterListCheckAndGetRender(struct AudioRender **render, struct HdfSBuf *data)
558 {
559     if (render == NULL || data == NULL) {
560         return HDF_FAILURE;
561     }
562     struct AudioRender *renderTemp = NULL;
563     const char *adapterName = NULL;
564     uint32_t pid = 0;
565     if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
566         HDF_LOGE("%{public}s: HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail ", __func__);
567         return HDF_FAILURE;
568     }
569     int ret = AudioAdapterListGetRender(adapterName, &renderTemp, pid);
570     if (ret < 0) {
571         return ret;
572     }
573     if (renderTemp == NULL) {
574         return HDF_FAILURE;
575     }
576     *render = renderTemp;
577     return HDF_SUCCESS;
578 }
579 
AudioAdapterCheckListExist(const char * adapterName)580 int32_t AudioAdapterCheckListExist(const char *adapterName)
581 {
582     int32_t i, num;
583 
584     LOG_FUN_INFO();
585     if (g_renderAndCaptureManage == NULL) {
586         return AUDIO_HAL_ERR_INVALID_PARAM;
587     }
588     if (adapterName == NULL) {
589         HDF_LOGE("%{public}s: The pointer is null. ", __func__);
590         return AUDIO_HAL_ERR_INVALID_PARAM;
591     }
592 
593     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
594     for (i = 0; i < num; i++) {
595         if (g_renderAndCaptureManage[i].adapterName == NULL) {
596             return AUDIO_HAL_ERR_INVALID_PARAM;
597         }
598         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
599             if (g_renderAndCaptureManage[i].adapterUserNum == 0) {
600                 return AUDIO_HAL_ERR_INTERNAL;
601             } else if (g_renderAndCaptureManage[i].adapterUserNum > 0) {
602                 g_renderAndCaptureManage[i].adapterUserNum++;
603                 return AUDIO_HAL_SUCCESS;
604             }
605         }
606     }
607     return AUDIO_HAL_ERR_INVALID_PARAM;
608 }
609 
AudioAdapterListDestory(const char * adapterName,struct AudioAdapter ** adapter)610 int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **adapter)
611 {
612     int32_t i, num;
613     if (adapter == NULL) {
614         return AUDIO_HAL_ERR_INVALID_PARAM;
615     }
616     LOG_FUN_INFO();
617     if (adapterName == NULL) {
618         HDF_LOGE("%{public}s: adapterName is NULL. ", __func__);
619         return AUDIO_HAL_ERR_INVALID_PARAM;
620     }
621     if (g_renderAndCaptureManage == NULL) {
622         return AUDIO_HAL_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 AUDIO_HAL_ERR_INVALID_PARAM;
628         }
629         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
630             if (g_renderAndCaptureManage[i].adapterUserNum == 1) {
631                 g_renderAndCaptureManage[i].adapterUserNum--;
632                 *adapter = g_renderAndCaptureManage[i].adapter;
633                 g_renderAndCaptureManage[i].adapter = NULL;
634                 return AUDIO_HAL_SUCCESS;
635             } else if (g_renderAndCaptureManage[i].adapterUserNum > 1) {
636                 g_renderAndCaptureManage[i].adapterUserNum--;
637                 return AUDIO_HAL_ERR_INTERNAL;
638             }
639         }
640     }
641     return AUDIO_HAL_ERR_INVALID_PARAM;
642 }
643 
AudioAdapterListAdd(const char * adapterName,struct AudioAdapter * adapter)644 int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapter)
645 {
646     int32_t i, num;
647 
648     LOG_FUN_INFO();
649     if (adapterName == NULL || adapter == NULL) {
650         HDF_LOGE("%{public}s: adapterName is NULL. ", __func__);
651         return HDF_ERR_INVALID_PARAM;
652     }
653     num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
654         MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
655     if (g_renderAndCaptureManage == NULL) {
656         return HDF_ERR_INVALID_PARAM;
657     }
658     for (i = 0; i < num; i++) {
659         if (g_renderAndCaptureManage[i].adapterName == NULL) {
660             return HDF_ERR_INVALID_PARAM;
661         }
662         if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
663             g_renderAndCaptureManage[i].adapter = adapter;
664             g_renderAndCaptureManage[i].adapterUserNum = 1;
665             return HDF_SUCCESS;
666         }
667     }
668     return HDF_ERR_INVALID_PARAM;
669 }
670 
HdiServicePositionWrite(struct HdfSBuf * reply,uint64_t frames,struct AudioTimeStamp time)671 int32_t HdiServicePositionWrite(struct HdfSBuf *reply,
672     uint64_t frames, struct AudioTimeStamp time)
673 {
674     if (reply == NULL) {
675         return HDF_FAILURE;
676     }
677     if (!HdfSbufWriteUint64(reply, frames)) {
678         return HDF_FAILURE;
679     }
680     if (!HdfSbufWriteInt64(reply, time.tvSec)) {
681         return HDF_FAILURE;
682     }
683     if (!HdfSbufWriteInt64(reply, time.tvNSec)) {
684         return HDF_FAILURE;
685     }
686     return HDF_SUCCESS;
687 }
688 
HdiServiceReqMmapBuffer(struct AudioMmapBufferDescriptor * desc,struct HdfSBuf * data)689 int32_t HdiServiceReqMmapBuffer(struct AudioMmapBufferDescriptor *desc, struct HdfSBuf *data)
690 {
691     int32_t ret;
692     if (desc == NULL || data == NULL) {
693         return AUDIO_HAL_ERR_INTERNAL;
694     }
695     uint64_t memAddr = 0;
696     if (!HdfSbufReadUint64(data, &memAddr)) {
697         HDF_LOGE("%{public}s: memAddr Is NULL", __func__);
698         return AUDIO_HAL_ERR_INTERNAL;
699     }
700     desc->memoryAddress = reinterpret_cast<void *>((uintptr_t)memAddr);
701     ret = HdfSbufReadFileDescriptor(data);
702     if (ret < 0) {
703         return HDF_FAILURE;
704     }
705     desc->memoryFd = ret;
706     if (!HdfSbufReadInt32(data, &desc->totalBufferFrames)) {
707         return AUDIO_HAL_ERR_INTERNAL;
708     }
709     if (!HdfSbufReadInt32(data, &desc->transferFrameSize)) {
710         return AUDIO_HAL_ERR_INTERNAL;
711     }
712     if (!HdfSbufReadInt32(data, &desc->isShareable)) {
713         return AUDIO_HAL_ERR_INTERNAL;
714     }
715     if (!HdfSbufReadUint32(data, &desc->offset)) {
716         return AUDIO_HAL_ERR_INTERNAL;
717     }
718     return AUDIO_HAL_SUCCESS;
719 }
720 }