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