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