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_LOGE("%{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 HDF_LOGE("%{public}s: renderPid = %{public}u, pid = %{public}u", __func__,
546 g_renderAndCaptureManage[i].renderPid, pid);
547 if (g_renderAndCaptureManage[i].renderPid != pid) {
548 HDF_LOGE("%{public}s: renderPid != pid ", __func__);
549 return AUDIO_HAL_ERR_INVALID_OBJECT;
550 }
551 *render = g_renderAndCaptureManage[i].render;
552 return HDF_SUCCESS;
553 }
554 }
555 return HDF_ERR_INVALID_PARAM;
556 }
557
AudioAdapterListCheckAndGetRender(struct AudioRender ** render,struct HdfSBuf * data)558 int32_t AudioAdapterListCheckAndGetRender(struct AudioRender **render, struct HdfSBuf *data)
559 {
560 if (render == NULL || data == NULL) {
561 return HDF_FAILURE;
562 }
563 struct AudioRender *renderTemp = NULL;
564 const char *adapterName = NULL;
565 uint32_t pid = 0;
566 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
567 HDF_LOGE("%{public}s: HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail ", __func__);
568 return HDF_FAILURE;
569 }
570 int ret = AudioAdapterListGetRender(adapterName, &renderTemp, pid);
571 if (ret < 0) {
572 return ret;
573 }
574 if (renderTemp == NULL) {
575 return HDF_FAILURE;
576 }
577 *render = renderTemp;
578 return HDF_SUCCESS;
579 }
580
AudioAdapterCheckListExist(const char * adapterName)581 int32_t AudioAdapterCheckListExist(const char *adapterName)
582 {
583 int32_t i, num;
584
585 LOG_FUN_INFO();
586 if (g_renderAndCaptureManage == NULL) {
587 return AUDIO_HAL_ERR_INVALID_PARAM;
588 }
589 if (adapterName == NULL) {
590 HDF_LOGE("%{public}s: The pointer is null. ", __func__);
591 return AUDIO_HAL_ERR_INVALID_PARAM;
592 }
593
594 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
595 for (i = 0; i < num; i++) {
596 if (g_renderAndCaptureManage[i].adapterName == NULL) {
597 return AUDIO_HAL_ERR_INVALID_PARAM;
598 }
599 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
600 if (g_renderAndCaptureManage[i].adapterUserNum == 0) {
601 return AUDIO_HAL_ERR_INTERNAL;
602 } else if (g_renderAndCaptureManage[i].adapterUserNum > 0) {
603 g_renderAndCaptureManage[i].adapterUserNum++;
604 return AUDIO_HAL_SUCCESS;
605 }
606 }
607 }
608 return AUDIO_HAL_ERR_INVALID_PARAM;
609 }
610
AudioAdapterListDestory(const char * adapterName,struct AudioAdapter ** adapter)611 int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **adapter)
612 {
613 int32_t i, num;
614 if (adapter == NULL) {
615 return AUDIO_HAL_ERR_INVALID_PARAM;
616 }
617 LOG_FUN_INFO();
618 if (adapterName == NULL) {
619 HDF_LOGE("%{public}s: adapterName is NULL. ", __func__);
620 return AUDIO_HAL_ERR_INVALID_PARAM;
621 }
622 if (g_renderAndCaptureManage == NULL) {
623 return AUDIO_HAL_ERR_INVALID_PARAM;
624 }
625 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
626 for (i = 0; i < num; i++) {
627 if (g_renderAndCaptureManage[i].adapterName == NULL) {
628 return AUDIO_HAL_ERR_INVALID_PARAM;
629 }
630 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
631 if (g_renderAndCaptureManage[i].adapterUserNum == 1) {
632 g_renderAndCaptureManage[i].adapterUserNum--;
633 *adapter = g_renderAndCaptureManage[i].adapter;
634 g_renderAndCaptureManage[i].adapter = NULL;
635 return AUDIO_HAL_SUCCESS;
636 } else if (g_renderAndCaptureManage[i].adapterUserNum > 1) {
637 g_renderAndCaptureManage[i].adapterUserNum--;
638 return AUDIO_HAL_ERR_INTERNAL;
639 }
640 }
641 }
642 return AUDIO_HAL_ERR_INVALID_PARAM;
643 }
644
AudioAdapterListAdd(const char * adapterName,struct AudioAdapter * adapter)645 int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapter)
646 {
647 int32_t i, num;
648
649 LOG_FUN_INFO();
650 if (adapterName == NULL || adapter == NULL) {
651 HDF_LOGE("%{public}s: adapterName is NULL. ", __func__);
652 return HDF_ERR_INVALID_PARAM;
653 }
654 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
655 MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
656 if (g_renderAndCaptureManage == NULL) {
657 return HDF_ERR_INVALID_PARAM;
658 }
659 for (i = 0; i < num; i++) {
660 if (g_renderAndCaptureManage[i].adapterName == NULL) {
661 return HDF_ERR_INVALID_PARAM;
662 }
663 if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) {
664 g_renderAndCaptureManage[i].adapter = adapter;
665 g_renderAndCaptureManage[i].adapterUserNum = 1;
666 return HDF_SUCCESS;
667 }
668 }
669 return HDF_ERR_INVALID_PARAM;
670 }
671
HdiServicePositionWrite(struct HdfSBuf * reply,uint64_t frames,struct AudioTimeStamp time)672 int32_t HdiServicePositionWrite(struct HdfSBuf *reply,
673 uint64_t frames, struct AudioTimeStamp time)
674 {
675 if (reply == NULL) {
676 return HDF_FAILURE;
677 }
678 if (!HdfSbufWriteUint64(reply, frames)) {
679 return HDF_FAILURE;
680 }
681 if (!HdfSbufWriteInt64(reply, time.tvSec)) {
682 return HDF_FAILURE;
683 }
684 if (!HdfSbufWriteInt64(reply, time.tvNSec)) {
685 return HDF_FAILURE;
686 }
687 return HDF_SUCCESS;
688 }
689
HdiServiceReqMmapBuffer(struct AudioMmapBufferDescripter * desc,struct HdfSBuf * data)690 int32_t HdiServiceReqMmapBuffer(struct AudioMmapBufferDescripter *desc, struct HdfSBuf *data)
691 {
692 int32_t ret;
693 if (desc == NULL || data == NULL) {
694 return AUDIO_HAL_ERR_INTERNAL;
695 }
696 uint64_t memAddr = 0;
697 if (!HdfSbufReadUint64(data, &memAddr)) {
698 HDF_LOGE("%{public}s: memAddr Is NULL", __func__);
699 return AUDIO_HAL_ERR_INTERNAL;
700 }
701 desc->memoryAddress = reinterpret_cast<void *>((uintptr_t)memAddr);
702 ret = HdfSbufReadFileDescriptor(data);
703 if (ret < 0) {
704 return HDF_FAILURE;
705 }
706 desc->memoryFd = ret;
707 if (!HdfSbufReadInt32(data, &desc->totalBufferFrames)) {
708 return AUDIO_HAL_ERR_INTERNAL;
709 }
710 if (!HdfSbufReadInt32(data, &desc->transferFrameSize)) {
711 return AUDIO_HAL_ERR_INTERNAL;
712 }
713 if (!HdfSbufReadInt32(data, &desc->isShareable)) {
714 return AUDIO_HAL_ERR_INTERNAL;
715 }
716 if (!HdfSbufReadUint32(data, &desc->offset)) {
717 return AUDIO_HAL_ERR_INTERNAL;
718 }
719 return AUDIO_HAL_SUCCESS;
720 }
721 }