1 /*
2 * Copyright (c) 2021-2023 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_adapter_info_common.h"
18 #include "audio_events.h"
19 #include "audio_types.h"
20 #include "audio_uhdf_log.h"
21 #include "hdf_audio_events.h"
22 #include "hdf_audio_server.h"
23 #include "hdf_audio_server_capture.h"
24 #include "hdf_audio_server_render.h"
25 #include "hdf_device_object.h"
26 #include "osal_mem.h"
27
28 #define HDF_LOG_TAG HDF_AUDIO_HAL_STUB
29
30 struct AudioAdapterDescriptor *g_descs = NULL;
31 struct AudioManager *g_serverManager = NULL;
32
33 #define MANAGER_ADAPTER_NAME_LEN 32
34 #define SERVER_INFO_LEN 128
35
36 int32_t g_serverAdapterNum = 0;
37 struct AudioInfoInAdapter *g_renderAndCaptureManage = NULL;
38
39 static struct AudioEvent g_audioEventPnp = {
40 .eventType = HDF_AUDIO_EVENT_UNKOWN,
41 .deviceType = HDF_AUDIO_DEVICE_UNKOWN,
42 };
43
44 static struct AudioEvent g_audioEventLoad = {
45 .eventType = HDF_AUDIO_EVENT_UNKOWN,
46 .deviceType = HDF_AUDIO_DEVICE_UNKOWN,
47 };
48
49 static struct AudioEvent g_audioEventService = {
50 .eventType = HDF_AUDIO_EVENT_UNKOWN,
51 .deviceType = HDF_AUDIO_DEVICE_UNKOWN,
52 };
53
AdapterManageInit(struct AudioInfoInAdapter * adapterManage,const char * adapterName)54 static int32_t AdapterManageInit(struct AudioInfoInAdapter *adapterManage,
55 const char *adapterName)
56 {
57 int32_t ret;
58
59 if (adapterManage == NULL || adapterName == NULL) {
60 AUDIO_FUNC_LOGE("Parameter error! ");
61
62 return HDF_FAILURE;
63 }
64
65 adapterManage->adapterName = (char *)OsalMemCalloc(MANAGER_ADAPTER_NAME_LEN);
66 if (adapterManage->adapterName == NULL) {
67 AUDIO_FUNC_LOGE("alloc adapter name failed!");
68 return HDF_FAILURE;
69 }
70
71 ret = memcpy_s((void *)adapterManage->adapterName, MANAGER_ADAPTER_NAME_LEN,
72 adapterName, strlen(adapterName));
73 if (ret != EOK) {
74 AUDIO_FUNC_LOGE("memcpy adapter name fail!");
75 AudioMemFree((void **)&adapterManage->adapterName);
76
77 return HDF_FAILURE;
78 }
79
80 adapterManage->adapter = NULL;
81 adapterManage->adapterUserNum = 0;
82 adapterManage->renderStatus = 0;
83 adapterManage->renderPriority = -1;
84 adapterManage->render = NULL;
85 adapterManage->renderBusy = false;
86 adapterManage->renderDestory = false;
87 adapterManage->renderPid = 0;
88 adapterManage->captureStatus = 0;
89 adapterManage->capturePriority = -1;
90 adapterManage->capture = NULL;
91 adapterManage->captureBusy = false;
92 adapterManage->captureDestory = false;
93 adapterManage->capturePid = 0;
94
95 return HDF_SUCCESS;
96 }
97
ServerManageGetAdapterNum(void)98 int32_t ServerManageGetAdapterNum(void)
99 {
100 return ((g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum);
101 }
102
ServerManageGetAdapters(void)103 struct AudioInfoInAdapter *ServerManageGetAdapters(void)
104 {
105 return g_renderAndCaptureManage;
106 }
107
108
AdaptersServerManageRelease(const struct AudioInfoInAdapter * adaptersManage,int32_t num)109 void AdaptersServerManageRelease(
110 const struct AudioInfoInAdapter *adaptersManage, int32_t num)
111 {
112 int32_t i;
113
114 if (adaptersManage == NULL || num <= 0) {
115 AUDIO_FUNC_LOGE("Parameter error! ");
116
117 return;
118 }
119 num = (num > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : num;
120 for (i = 0; i < num; i++) {
121 if (adaptersManage[i].adapterName != NULL) {
122 AudioMemFree((void **)&adaptersManage[i].adapterName);
123 }
124 }
125 AudioMemFree((void **)&adaptersManage);
126 }
127
AdaptersServerManageInfomationRecycle(void)128 void AdaptersServerManageInfomationRecycle(void)
129 {
130 AdaptersServerManageRelease(g_renderAndCaptureManage, g_serverAdapterNum);
131 g_renderAndCaptureManage = NULL;
132 g_serverAdapterNum = 0;
133 }
134
AdaptersServerManageInit(const struct AudioAdapterDescriptor * descs,int32_t num)135 int32_t AdaptersServerManageInit(const struct AudioAdapterDescriptor *descs, int32_t num)
136 {
137 int32_t i, ret;
138 struct AudioInfoInAdapter *adaptersManage = NULL;
139
140 if (descs == NULL || num <= 0) {
141 AUDIO_FUNC_LOGE("Parameter error! ");
142
143 return HDF_FAILURE;
144 }
145
146 num = (num > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : num;
147 adaptersManage = (struct AudioInfoInAdapter *)OsalMemCalloc(
148 num * sizeof(struct AudioInfoInAdapter));
149 if (adaptersManage == NULL) {
150 AUDIO_FUNC_LOGE("alloc adaptersManage failed!");
151
152 return HDF_FAILURE;
153 }
154 for (i = 0; i < num; i++) {
155 ret = AdapterManageInit(&adaptersManage[i], descs[i].adapterName);
156 if (ret != HDF_SUCCESS) {
157 AdaptersServerManageRelease(adaptersManage, num);
158
159 return ret;
160 }
161 }
162 g_serverAdapterNum = num;
163 g_renderAndCaptureManage = adaptersManage;
164
165 return HDF_SUCCESS;
166 }
167
HdiServiceRenderCaptureReadData(struct HdfSBuf * data,const char ** adapterName,uint32_t * pid)168 int32_t HdiServiceRenderCaptureReadData(struct HdfSBuf *data, const char **adapterName, uint32_t *pid)
169 {
170 if (adapterName == NULL || data == NULL || pid == NULL) {
171 return HDF_FAILURE;
172 }
173 if ((*adapterName = HdfSbufReadString(data)) == NULL) {
174 AUDIO_FUNC_LOGE("adapterName Is NULL ");
175 return HDF_FAILURE;
176 }
177 if (!HdfSbufReadUint32(data, pid)) {
178 AUDIO_FUNC_LOGE("read buf fail ");
179 return HDF_FAILURE;
180 }
181 return HDF_SUCCESS;
182 }
183
AudioAdapterListGetAdapterCapture(const char * adapterName,struct AudioAdapter ** adapter,struct AudioCapture ** capture)184 int32_t AudioAdapterListGetAdapterCapture(const char *adapterName,
185 struct AudioAdapter **adapter, struct AudioCapture **capture)
186 {
187 int32_t i, num;
188
189 AUDIO_FUNC_LOGI();
190 if (adapterName == NULL || adapter == NULL || capture == NULL) {
191 AUDIO_FUNC_LOGE("The pointer is null ");
192 return HDF_ERR_INVALID_PARAM;
193 }
194 if (g_renderAndCaptureManage == NULL) {
195 return HDF_ERR_INVALID_PARAM;
196 }
197 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
198 for (i = 0; i < num; i++) {
199 if (g_renderAndCaptureManage[i].adapterName == NULL) {
200 AUDIO_FUNC_LOGE("The pointer is null ");
201 return HDF_ERR_INVALID_PARAM;
202 }
203 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
204 *adapter = g_renderAndCaptureManage[i].adapter;
205 *capture = g_renderAndCaptureManage[i].capture;
206 return HDF_SUCCESS;
207 }
208 }
209 return HDF_ERR_INVALID_PARAM;
210 }
211
AudioDestroyCaptureInfoInAdapter(const char * adapterName)212 int32_t AudioDestroyCaptureInfoInAdapter(const char *adapterName)
213 {
214 int32_t i;
215
216 AUDIO_FUNC_LOGI();
217 if (adapterName == NULL) {
218 AUDIO_FUNC_LOGE("Param Is NULL ");
219 return HDF_FAILURE;
220 }
221
222 int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
223 MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
224 if (g_renderAndCaptureManage == NULL) {
225 return HDF_FAILURE;
226 }
227 for (i = 0; i < num; i++) {
228 if (g_renderAndCaptureManage[i].adapterName == NULL) {
229 return HDF_FAILURE;
230 }
231 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
232 g_renderAndCaptureManage[i].captureStatus = 0;
233 g_renderAndCaptureManage[i].capturePriority = -1;
234 g_renderAndCaptureManage[i].capture = NULL;
235 g_renderAndCaptureManage[i].capturePid = 0;
236 return HDF_SUCCESS;
237 }
238 }
239 AUDIO_FUNC_LOGE("Can not find Adapter! ");
240 return HDF_FAILURE;
241 }
242
AudioDestroyFormerCapture(struct AudioInfoInAdapter * captureManage)243 static int32_t AudioDestroyFormerCapture(struct AudioInfoInAdapter *captureManage)
244 {
245 AUDIO_FUNC_LOGI();
246 if (captureManage == NULL || captureManage->adapter == NULL || captureManage->capture == NULL) {
247 AUDIO_FUNC_LOGE("input para is NULL ");
248 return HDF_FAILURE;
249 }
250 int count = 0;
251 captureManage->captureDestory = true;
252 while (captureManage->captureBusy) {
253 if (count > 1000) { // Less than 1000
254 AUDIO_FUNC_LOGE(", count = %{public}d", count);
255 captureManage->captureDestory = false;
256 return AUDIO_HAL_ERR_AI_BUSY; // capture is busy now
257 }
258 usleep(500); // sleep 500us
259 count++;
260 }
261 captureManage->capturePid = 0;
262 if (captureManage->adapter->DestroyCapture(captureManage->adapter, captureManage->capture)) {
263 captureManage->captureDestory = false;
264 return HDF_FAILURE;
265 }
266 captureManage->capture = NULL;
267 captureManage->captureStatus = 0;
268 captureManage->captureBusy = false;
269 captureManage->captureDestory = false;
270 captureManage->renderPriority = -1;
271 return HDF_SUCCESS;
272 }
273
AudioJudgeCapturePriority(const int32_t priority,int which)274 static int32_t AudioJudgeCapturePriority(const int32_t priority, int which)
275 {
276 int num;
277 if (g_renderAndCaptureManage == NULL) {
278 return HDF_FAILURE;
279 }
280 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
281 if (which < 0 || which >= num) {
282 AUDIO_FUNC_LOGE("invalid value! ");
283 return HDF_FAILURE;
284 }
285 if (!(g_renderAndCaptureManage[which].captureStatus)) {
286 return HDF_SUCCESS;
287 } else {
288 if (g_renderAndCaptureManage[which].capturePriority <= priority) {
289 return AudioDestroyFormerCapture(&g_renderAndCaptureManage[which]);
290 } else {
291 return AUDIO_HAL_ERR_AI_BUSY; // capture is busy now
292 }
293 }
294 return HDF_FAILURE;
295 }
296
AudioCreatCaptureCheck(const char * adapterName,const int32_t priority)297 int32_t AudioCreatCaptureCheck(const char *adapterName, const int32_t priority)
298 {
299 int32_t i, num;
300
301 AUDIO_FUNC_LOGI();
302 if (adapterName == NULL) {
303 return HDF_FAILURE;
304 }
305 if (g_renderAndCaptureManage == NULL) {
306 return HDF_FAILURE;
307 }
308 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
309 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) == 0) {
315 return AudioJudgeCapturePriority(priority, i);
316 }
317 }
318 AUDIO_FUNC_LOGE("Can not find Adapter! ");
319 return HDF_FAILURE;
320 }
321
AudioAddCaptureInfoInAdapter(const char * adapterName,struct AudioCapture * capture,const struct AudioAdapter * adapter,const int32_t priority,uint32_t capturePid)322 int32_t AudioAddCaptureInfoInAdapter(const char *adapterName,
323 struct AudioCapture *capture,
324 const struct AudioAdapter *adapter,
325 const int32_t priority,
326 uint32_t capturePid)
327 {
328 int32_t i, num;
329
330 if (adapterName == NULL || adapter == NULL || capture == NULL) {
331 AUDIO_FUNC_LOGE("input para is NULL. ");
332 return HDF_FAILURE;
333 }
334 if (g_renderAndCaptureManage == NULL) {
335 return HDF_FAILURE;
336 }
337 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
338 for (i = 0; i < num; i++) {
339 if (g_renderAndCaptureManage == NULL || g_renderAndCaptureManage[i].adapterName == NULL) {
340 return HDF_FAILURE;
341 }
342 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
343 g_renderAndCaptureManage[i].captureStatus = 1;
344 g_renderAndCaptureManage[i].capturePriority = priority;
345 g_renderAndCaptureManage[i].capture = capture;
346 g_renderAndCaptureManage[i].capturePid = capturePid;
347 AUDIO_FUNC_LOGI(", (uint64_t)g_renderAndCaptureManage[%{public}d].capture = %{public}p",
348 i, g_renderAndCaptureManage[i].capture);
349 return HDF_SUCCESS;
350 }
351 }
352 AUDIO_FUNC_LOGE("Can not find Adapter! ");
353 return HDF_FAILURE;
354 }
355
WriteAudioSampleAttributes(struct HdfSBuf * reply,const struct AudioSampleAttributes * attrs)356 int32_t WriteAudioSampleAttributes(struct HdfSBuf *reply, const struct AudioSampleAttributes *attrs)
357 {
358 if (reply == NULL || attrs == NULL) {
359 return HDF_FAILURE;
360 }
361 uint32_t tempAttrParam = (uint32_t)attrs->type;
362 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
363 return HDF_FAILURE;
364 }
365 tempAttrParam = (uint32_t)attrs->interleaved;
366 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
367 return HDF_FAILURE;
368 }
369 tempAttrParam = (uint32_t)attrs->format;
370 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
371 return HDF_FAILURE;
372 }
373 if (!HdfSbufWriteUint32(reply, attrs->sampleRate)) {
374 return HDF_FAILURE;
375 }
376 if (!HdfSbufWriteUint32(reply, attrs->channelCount)) {
377 return HDF_FAILURE;
378 }
379 if (!HdfSbufWriteUint32(reply, attrs->period)) {
380 return HDF_FAILURE;
381 }
382 if (!HdfSbufWriteUint32(reply, attrs->frameSize)) {
383 return HDF_FAILURE;
384 }
385 tempAttrParam = (uint32_t)(attrs->isBigEndian);
386 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
387 return HDF_FAILURE;
388 }
389 tempAttrParam = (uint32_t)(attrs->isSignedData);
390 if (!HdfSbufWriteUint32(reply, tempAttrParam)) {
391 return HDF_FAILURE;
392 }
393 if (!HdfSbufWriteUint32(reply, attrs->startThreshold)) {
394 return HDF_FAILURE;
395 }
396 if (!HdfSbufWriteUint32(reply, attrs->stopThreshold)) {
397 return HDF_FAILURE;
398 }
399 if (!HdfSbufWriteUint32(reply, attrs->silenceThreshold)) {
400 return HDF_FAILURE;
401 }
402 return HDF_SUCCESS;
403 }
404
ReadAudioSapmleAttrbutes(struct HdfSBuf * data,struct AudioSampleAttributes * attrs)405 int32_t ReadAudioSapmleAttrbutes(struct HdfSBuf *data, struct AudioSampleAttributes *attrs)
406 {
407 if (data == NULL || attrs == NULL) {
408 return HDF_FAILURE;
409 }
410 uint32_t tempAttrParam = 0;
411 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
412 return HDF_FAILURE;
413 }
414 attrs->type = (enum AudioCategory)tempAttrParam;
415 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
416 return HDF_FAILURE;
417 }
418 attrs->interleaved = (bool)tempAttrParam;
419 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
420 return HDF_FAILURE;
421 }
422 attrs->format = (enum AudioFormat)tempAttrParam;
423 if (!HdfSbufReadUint32(data, &(attrs->sampleRate))) {
424 return HDF_FAILURE;
425 }
426 if (!HdfSbufReadUint32(data, &(attrs->channelCount))) {
427 return HDF_FAILURE;
428 }
429 if (!HdfSbufReadUint32(data, &(attrs->period))) {
430 return HDF_FAILURE;
431 }
432 if (!HdfSbufReadUint32(data, &(attrs->frameSize))) {
433 return HDF_FAILURE;
434 }
435 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
436 return HDF_FAILURE;
437 }
438 attrs->isBigEndian = (bool)tempAttrParam;
439 if (!HdfSbufReadUint32(data, &tempAttrParam)) {
440 return HDF_FAILURE;
441 }
442 attrs->isSignedData = (bool)tempAttrParam;
443 if (!HdfSbufReadUint32(data, &(attrs->startThreshold))) {
444 return HDF_FAILURE;
445 }
446 if (!HdfSbufReadUint32(data, &(attrs->stopThreshold))) {
447 return HDF_FAILURE;
448 }
449 if (!HdfSbufReadUint32(data, &(attrs->silenceThreshold))) {
450 return HDF_FAILURE;
451 }
452 return HDF_SUCCESS;
453 }
454
AudioAdapterListGetAdapter(const char * adapterName,struct AudioAdapter ** adapter)455 int32_t AudioAdapterListGetAdapter(const char *adapterName, struct AudioAdapter **adapter)
456 {
457 int32_t i, num;
458
459 AUDIO_FUNC_LOGI();
460 if (g_renderAndCaptureManage == NULL) {
461 return HDF_ERR_INVALID_PARAM;
462 }
463 if (adapterName == NULL || adapter == NULL) {
464 AUDIO_FUNC_LOGE("The pointer is null ");
465 return HDF_ERR_INVALID_PARAM;
466 }
467
468 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
469 MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
470 for (i = 0; i < num; i++) {
471 if (g_renderAndCaptureManage[i].adapterName == NULL) {
472 return HDF_ERR_INVALID_PARAM;
473 }
474 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
475 *adapter = g_renderAndCaptureManage[i].adapter;
476 return HDF_SUCCESS;
477 }
478 }
479 return HDF_ERR_INVALID_PARAM;
480 }
481
AudioDestroyFormerRender(struct AudioInfoInAdapter * renderManage)482 static int32_t AudioDestroyFormerRender(struct AudioInfoInAdapter *renderManage)
483 {
484 AUDIO_FUNC_LOGI();
485 if (renderManage == NULL || renderManage->adapter == NULL || renderManage->render == NULL) {
486 AUDIO_FUNC_LOGE("input para is NULL. ");
487 return HDF_FAILURE;
488 }
489 int count = 0;
490 renderManage->renderDestory = true;
491 while (renderManage->renderBusy) {
492 if (count > 1000) { // Less than 1000
493 AUDIO_FUNC_LOGE(", count = %{public}d", count);
494 renderManage->renderDestory = false;
495 return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
496 }
497 usleep(500); // sleep 500us
498 count++;
499 }
500 renderManage->renderPid = 0;
501 if (renderManage->adapter->DestroyRender(renderManage->adapter, renderManage->render)) {
502 renderManage->renderDestory = false;
503 return HDF_FAILURE;
504 }
505 renderManage->render = NULL;
506 renderManage->renderStatus = 0;
507 renderManage->renderBusy = false;
508 renderManage->renderDestory = false;
509 renderManage->renderPriority = -1;
510 return HDF_SUCCESS;
511 }
512
AudioJudgeRenderPriority(const int32_t priority,int which)513 static int32_t AudioJudgeRenderPriority(const int32_t priority, int which)
514 {
515 int32_t num;
516
517 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
518 if (which < 0 || which >= num) {
519 AUDIO_FUNC_LOGE("invalid value! ");
520 return HDF_FAILURE;
521 }
522 if (g_renderAndCaptureManage == NULL) {
523 return HDF_FAILURE;
524 }
525 if (g_renderAndCaptureManage[which].renderPriority <= priority) {
526 if (AudioDestroyFormerRender(&g_renderAndCaptureManage[which])) {
527 AUDIO_FUNC_LOGE("AudioDestroyFormerRender: Fail. ");
528 return HDF_FAILURE;
529 }
530 return HDF_SUCCESS;
531 } else {
532 return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
533 }
534 return HDF_FAILURE;
535 }
536
AudioCreatRenderCheck(const char * adapterName,const int32_t priority)537 int32_t AudioCreatRenderCheck(const char *adapterName, const int32_t priority)
538 {
539 int32_t i;
540
541 AUDIO_FUNC_LOGI();
542 if (adapterName == NULL || g_renderAndCaptureManage == NULL) {
543 return HDF_FAILURE;
544 }
545
546 int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
547 MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
548 for (i = 0; i < num; i++) {
549 if (g_renderAndCaptureManage[i].adapterName == NULL) {
550 return HDF_FAILURE;
551 }
552 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
553 if (!(g_renderAndCaptureManage[i].renderStatus)) {
554 return HDF_SUCCESS;
555 } else {
556 return AudioJudgeRenderPriority(priority, i);
557 }
558 }
559 }
560 AUDIO_FUNC_LOGE("Can not find Adapter! ");
561 return HDF_FAILURE;
562 }
563
AudioAddRenderInfoInAdapter(const char * adapterName,struct AudioRender * render,const struct AudioAdapter * adapter,const int32_t priority,uint32_t renderPid)564 int32_t AudioAddRenderInfoInAdapter(const char *adapterName,
565 struct AudioRender *render,
566 const struct AudioAdapter *adapter,
567 const int32_t priority,
568 uint32_t renderPid)
569 {
570 int32_t i, num;
571
572 if (adapterName == NULL || adapter == NULL || render == NULL) {
573 AUDIO_FUNC_LOGE("input para is NULL. ");
574 return HDF_FAILURE;
575 }
576 if (g_renderAndCaptureManage == NULL) {
577 return HDF_FAILURE;
578 }
579 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
580 for (i = 0; i < num; i++) {
581 if (g_renderAndCaptureManage[i].adapterName == NULL) {
582 return HDF_FAILURE;
583 }
584 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
585 g_renderAndCaptureManage[i].renderStatus = 1;
586 g_renderAndCaptureManage[i].renderPriority = priority;
587 g_renderAndCaptureManage[i].render = render;
588 g_renderAndCaptureManage[i].renderPid = renderPid;
589 return HDF_SUCCESS;
590 }
591 }
592 AUDIO_FUNC_LOGE("Can not find Adapter! ");
593 return HDF_FAILURE;
594 }
595
AudioSetRenderStatus(const char * adapterName,bool renderStatus)596 void AudioSetRenderStatus(const char *adapterName, bool renderStatus)
597 {
598 int32_t i, num;
599 if (g_renderAndCaptureManage == NULL) {
600 return;
601 }
602 if (adapterName == NULL) {
603 AUDIO_FUNC_LOGE("adapterName is null ");
604 return;
605 }
606
607 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
608 for (i = 0; i < num; i++) {
609 if (g_renderAndCaptureManage[i].adapterName == NULL) {
610 return;
611 }
612 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
613 g_renderAndCaptureManage[i].renderBusy = renderStatus;
614 return;
615 }
616 }
617 AUDIO_FUNC_LOGE("AudioDestroyRenderInfoInAdapter: Can not find Adapter! ");
618 return;
619 }
620
AudioGetRenderStatus(const char * adapterName)621 int32_t AudioGetRenderStatus(const char *adapterName)
622 {
623 int32_t i;
624 int32_t num;
625 if (adapterName == NULL || g_renderAndCaptureManage == NULL) {
626 return HDF_FAILURE;
627 }
628
629 num = (g_serverAdapterNum >
630 MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
631 for (i = 0; i < num; i++) {
632 if (g_renderAndCaptureManage[i].adapterName == NULL) {
633 return HDF_FAILURE;
634 }
635 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
636 if (!g_renderAndCaptureManage[i].renderDestory) {
637 return HDF_SUCCESS;
638 } else {
639 g_renderAndCaptureManage[i].renderBusy = false;
640 return HDF_FAILURE;
641 }
642 }
643 }
644 AUDIO_FUNC_LOGE("AudioDestroyRenderInfoInAdapter: Can not find Adapter! ");
645 return HDF_FAILURE;
646 }
647
AudioDestroyRenderInfoInAdapter(const char * adapterName)648 int32_t AudioDestroyRenderInfoInAdapter(const char *adapterName)
649 {
650 int32_t i, num;
651
652 AUDIO_FUNC_LOGI();
653 if (adapterName == NULL) {
654 AUDIO_FUNC_LOGE("adapterName is null ");
655 return HDF_FAILURE;
656 }
657
658 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
659 if (g_renderAndCaptureManage == NULL) {
660 return HDF_FAILURE;
661 }
662 for (i = 0; i < num; i++) {
663 if (g_renderAndCaptureManage[i].adapterName == NULL) {
664 return HDF_FAILURE;
665 }
666 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
667 g_renderAndCaptureManage[i].renderStatus = 0;
668 g_renderAndCaptureManage[i].renderPriority = -1;
669 g_renderAndCaptureManage[i].render = NULL;
670 g_renderAndCaptureManage[i].renderPid = 0;
671 return HDF_SUCCESS;
672 }
673 }
674 AUDIO_FUNC_LOGE("Can not find Adapter! ");
675 return HDF_FAILURE;
676 }
677
AudioAdapterListGetAdapterRender(const char * adapterName,struct AudioAdapter ** adapter,struct AudioRender ** render)678 int32_t AudioAdapterListGetAdapterRender(const char *adapterName,
679 struct AudioAdapter **adapter, struct AudioRender **render)
680 {
681 int32_t i, num;
682
683 AUDIO_FUNC_LOGI();
684 if (g_renderAndCaptureManage == NULL) {
685 return HDF_ERR_INVALID_PARAM;
686 }
687 if (adapterName == NULL || adapter == NULL || render == NULL) {
688 AUDIO_FUNC_LOGE("The pointer is null ");
689 return HDF_ERR_INVALID_PARAM;
690 }
691
692 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
693 for (i = 0; i < num; i++) {
694 if (g_renderAndCaptureManage[i].adapterName == NULL) {
695 return HDF_ERR_INVALID_PARAM;
696 }
697 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
698 *adapter = g_renderAndCaptureManage[i].adapter;
699 *render = g_renderAndCaptureManage[i].render;
700 return HDF_SUCCESS;
701 }
702 }
703 return HDF_ERR_INVALID_PARAM;
704 }
705
AudioAdapterListGetRender(const char * adapterName,struct AudioRender ** render,uint32_t pid)706 int32_t AudioAdapterListGetRender(const char *adapterName, struct AudioRender **render, uint32_t pid)
707 {
708 int32_t num;
709 if (g_renderAndCaptureManage == NULL) {
710 return HDF_ERR_INVALID_PARAM;
711 }
712 if (adapterName == NULL || render == NULL) {
713 AUDIO_FUNC_LOGE("pointer is null ");
714 return HDF_ERR_INVALID_PARAM;
715 }
716 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
717 for (int32_t i = 0; i < num; i++) {
718 if (g_renderAndCaptureManage[i].adapterName == NULL) {
719 return HDF_ERR_INVALID_PARAM;
720 }
721 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
722 if (g_renderAndCaptureManage[i].renderPid != pid) {
723 AUDIO_FUNC_LOGE("[%{public}d].renderPid:%{public}d != pid:%{public}d ", i,
724 g_renderAndCaptureManage[i].renderPid, pid);
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 AUDIO_FUNC_LOGE("The pointer is null");
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) == 0) {
750 if (g_renderAndCaptureManage[i].capturePid != pid) {
751 AUDIO_FUNC_LOGE("managerList[%{public}d].capturePid:%{public}d != pid:%{public}d ", i,
752 g_renderAndCaptureManage[i].capturePid, pid);
753 return AUDIO_HAL_ERR_INVALID_OBJECT;
754 }
755 *capture = g_renderAndCaptureManage[i].capture;
756 return HDF_SUCCESS;
757 }
758 }
759 return HDF_ERR_INVALID_PARAM;
760 }
761
AudioAdapterFrameGetCapture(const char * adapterName,struct AudioCapture ** capture,uint32_t pid,uint32_t * index)762 int32_t AudioAdapterFrameGetCapture(const char *adapterName,
763 struct AudioCapture **capture, uint32_t pid, uint32_t *index)
764 {
765 int32_t i, num;
766 if (adapterName == NULL || capture == NULL || index == NULL || g_renderAndCaptureManage == NULL) {
767 AUDIO_FUNC_LOGE("The pointer is null");
768 return HDF_ERR_INVALID_PARAM;
769 }
770 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
771 *index = MAX_AUDIO_ADAPTER_NUM_SERVER;
772 for (i = 0; i < num; i++) {
773 if (g_renderAndCaptureManage[i].adapterName == NULL) {
774 return HDF_ERR_INVALID_PARAM;
775 }
776 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
777 if (g_renderAndCaptureManage[i].capturePid != pid) {
778 AUDIO_FUNC_LOGE("[%{public}d].capturePid: %{public}d != pid: %{public}d ", i,
779 g_renderAndCaptureManage[i].capturePid, pid);
780 return AUDIO_HAL_ERR_INVALID_OBJECT;
781 }
782 if (!g_renderAndCaptureManage[i].captureDestory) {
783 *capture = g_renderAndCaptureManage[i].capture;
784 *index = i;
785 return HDF_SUCCESS;
786 } else {
787 g_renderAndCaptureManage[i].captureBusy = false;
788 return HDF_FAILURE;
789 }
790 }
791 }
792 return HDF_FAILURE;
793 }
794
AudioAdapterListCheckAndGetRender(struct AudioRender ** render,struct HdfSBuf * data)795 int32_t AudioAdapterListCheckAndGetRender(struct AudioRender **render, struct HdfSBuf *data)
796 {
797 if (render == NULL || data == NULL) {
798 AUDIO_FUNC_LOGE("render or data is null!");
799 return HDF_FAILURE;
800 }
801 struct AudioRender *renderTemp = NULL;
802 const char *adapterName = NULL;
803 uint32_t pid = 0;
804 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
805 AUDIO_FUNC_LOGE("HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail ");
806 return HDF_FAILURE;
807 }
808 int ret = AudioAdapterListGetRender(adapterName, &renderTemp, pid);
809 if (ret < 0) {
810 return ret;
811 }
812 if (renderTemp == NULL) {
813 return HDF_FAILURE;
814 }
815 *render = renderTemp;
816 return HDF_SUCCESS;
817 }
818
AudioAdapterListCheckAndGetCapture(struct AudioCapture ** capture,struct HdfSBuf * data)819 int32_t AudioAdapterListCheckAndGetCapture(struct AudioCapture **capture, struct HdfSBuf *data)
820 {
821 if (capture == NULL || data == NULL) {
822 AUDIO_FUNC_LOGE("capture or data is null!");
823 return HDF_FAILURE;
824 }
825 struct AudioCapture *captureTemp = NULL;
826 const char *adapterName = NULL;
827 uint32_t pid = 0;
828 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
829 AUDIO_FUNC_LOGE("HdiServiceCaptureStart: HdiServiceRenderCaptureReadData fail ");
830 return HDF_FAILURE;
831 }
832 int ret = AudioAdapterListGetCapture(adapterName, &captureTemp, pid);
833 if (ret < 0) {
834 return ret;
835 }
836 if (captureTemp == NULL) {
837 return HDF_FAILURE;
838 }
839 *capture = captureTemp;
840 return HDF_SUCCESS;
841 }
842
AudioAdapterCheckListExist(const char * adapterName)843 int32_t AudioAdapterCheckListExist(const char *adapterName)
844 {
845 int32_t i, num;
846
847 AUDIO_FUNC_LOGI();
848 if (g_renderAndCaptureManage == NULL) {
849 return AUDIO_HAL_ERR_INVALID_PARAM;
850 }
851 if (adapterName == NULL) {
852 AUDIO_FUNC_LOGE("The pointer is null. ");
853 return AUDIO_HAL_ERR_INVALID_PARAM;
854 }
855
856 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
857 for (i = 0; i < num; i++) {
858 if (g_renderAndCaptureManage[i].adapterName == NULL) {
859 return AUDIO_HAL_ERR_INVALID_PARAM;
860 }
861 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
862 if (g_renderAndCaptureManage[i].adapterUserNum == 0) {
863 return AUDIO_HAL_ERR_INTERNAL;
864 } else if (g_renderAndCaptureManage[i].adapterUserNum > 0) {
865 g_renderAndCaptureManage[i].adapterUserNum++;
866 return AUDIO_HAL_SUCCESS;
867 }
868 }
869 }
870 return AUDIO_HAL_ERR_INVALID_PARAM;
871 }
872
AudioAdapterListDestory(const char * adapterName,struct AudioAdapter ** adapter)873 int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **adapter)
874 {
875 int32_t i, num;
876 if (adapter == NULL) {
877 return AUDIO_HAL_ERR_INVALID_PARAM;
878 }
879 AUDIO_FUNC_LOGI();
880 if (adapterName == NULL) {
881 AUDIO_FUNC_LOGE("adapterName is NULL. ");
882 return AUDIO_HAL_ERR_INVALID_PARAM;
883 }
884 if (g_renderAndCaptureManage == NULL) {
885 return AUDIO_HAL_ERR_INVALID_PARAM;
886 }
887 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
888 for (i = 0; i < num; i++) {
889 if (g_renderAndCaptureManage[i].adapterName == NULL) {
890 return AUDIO_HAL_ERR_INVALID_PARAM;
891 }
892 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
893 if (g_renderAndCaptureManage[i].adapterUserNum == 1) {
894 g_renderAndCaptureManage[i].adapterUserNum--;
895 *adapter = g_renderAndCaptureManage[i].adapter;
896 g_renderAndCaptureManage[i].adapter = NULL;
897 return AUDIO_HAL_SUCCESS;
898 } else if (g_renderAndCaptureManage[i].adapterUserNum > 1) {
899 g_renderAndCaptureManage[i].adapterUserNum--;
900 return AUDIO_HAL_ERR_INTERNAL;
901 }
902 }
903 }
904 return AUDIO_HAL_ERR_INVALID_PARAM;
905 }
906
AudioAdapterListAdd(const char * adapterName,struct AudioAdapter * adapter)907 int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapter)
908 {
909 int32_t i, num;
910
911 AUDIO_FUNC_LOGI();
912 if (adapterName == NULL || adapter == NULL) {
913 AUDIO_FUNC_LOGE("adapterName is NULL. ");
914 return HDF_ERR_INVALID_PARAM;
915 }
916 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ?
917 MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
918 if (g_renderAndCaptureManage == NULL) {
919 return HDF_ERR_INVALID_PARAM;
920 }
921 for (i = 0; i < num; i++) {
922 if (g_renderAndCaptureManage[i].adapterName == NULL) {
923 return HDF_ERR_INVALID_PARAM;
924 }
925 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
926 g_renderAndCaptureManage[i].adapter = adapter;
927 g_renderAndCaptureManage[i].adapterUserNum = 1;
928 return HDF_SUCCESS;
929 }
930 }
931 return HDF_ERR_INVALID_PARAM;
932 }
933
AudioSetCaptureStatus(const char * adapterName,bool captureStatus)934 void AudioSetCaptureStatus(const char *adapterName, bool captureStatus)
935 {
936 int32_t i, num;
937 if (adapterName == NULL || g_renderAndCaptureManage == NULL) {
938 return;
939 }
940
941 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
942 for (i = 0; i < num; i++) {
943 if (g_renderAndCaptureManage[i].adapterName == NULL) {
944 return;
945 }
946 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
947 g_renderAndCaptureManage[i].captureBusy = captureStatus;
948 return;
949 }
950 }
951 return;
952 }
953
AudioSetCaptureBusy(uint32_t index,bool captureStatus)954 void AudioSetCaptureBusy(uint32_t index, bool captureStatus)
955 {
956 if (index < MAX_AUDIO_ADAPTER_NUM_SERVER && g_renderAndCaptureManage != NULL) {
957 g_renderAndCaptureManage[index].captureBusy = captureStatus;
958 }
959 return;
960 }
961
AudioGetCaptureStatus(const char * adapterName)962 int32_t AudioGetCaptureStatus(const char *adapterName)
963 {
964 int32_t i, num;
965 if (adapterName == NULL || g_renderAndCaptureManage == NULL) {
966 return HDF_FAILURE;
967 }
968
969 num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum;
970 for (i = 0; i < num; i++) {
971 if (g_renderAndCaptureManage[i].adapterName == NULL) {
972 return HDF_FAILURE;
973 }
974 if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
975 if (!g_renderAndCaptureManage[i].captureDestory) {
976 return HDF_SUCCESS;
977 } else {
978 g_renderAndCaptureManage[i].captureBusy = false;
979 return HDF_FAILURE;
980 }
981 }
982 }
983 return HDF_FAILURE;
984 }
985
HdiServicePositionWrite(struct HdfSBuf * reply,uint64_t frames,struct AudioTimeStamp time)986 int32_t HdiServicePositionWrite(struct HdfSBuf *reply,
987 uint64_t frames, struct AudioTimeStamp time)
988 {
989 if (reply == NULL) {
990 return HDF_FAILURE;
991 }
992 if (!HdfSbufWriteUint64(reply, frames)) {
993 return HDF_FAILURE;
994 }
995 if (!HdfSbufWriteInt64(reply, time.tvSec)) {
996 return HDF_FAILURE;
997 }
998 if (!HdfSbufWriteInt64(reply, time.tvNSec)) {
999 return HDF_FAILURE;
1000 }
1001 return HDF_SUCCESS;
1002 }
1003
HdiServiceReqMmapBuffer(struct AudioMmapBufferDescripter * desc,struct HdfSBuf * data)1004 int32_t HdiServiceReqMmapBuffer(struct AudioMmapBufferDescripter *desc, struct HdfSBuf *data)
1005 {
1006 int32_t ret;
1007 if (desc == NULL || data == NULL) {
1008 AUDIO_FUNC_LOGE("desc or data is null!");
1009 return AUDIO_HAL_ERR_INTERNAL;
1010 }
1011 uint64_t memAddr = 0;
1012 if (!HdfSbufReadUint64(data, &memAddr)) {
1013 AUDIO_FUNC_LOGE("memAddr Is NULL");
1014 return AUDIO_HAL_ERR_INTERNAL;
1015 }
1016 desc->memoryAddress = (void *)(uintptr_t)memAddr;
1017 ret = HdfSbufReadFileDescriptor(data);
1018 if (ret < 0) {
1019 return AUDIO_HAL_ERR_INTERNAL;
1020 }
1021 desc->memoryFd = ret;
1022 if (!HdfSbufReadInt32(data, &desc->totalBufferFrames)) {
1023 return AUDIO_HAL_ERR_INTERNAL;
1024 }
1025 if (!HdfSbufReadInt32(data, &desc->transferFrameSize)) {
1026 return AUDIO_HAL_ERR_INTERNAL;
1027 }
1028 if (!HdfSbufReadInt32(data, &desc->isShareable)) {
1029 return AUDIO_HAL_ERR_INTERNAL;
1030 }
1031 if (!HdfSbufReadUint32(data, &desc->offset)) {
1032 return AUDIO_HAL_ERR_INTERNAL;
1033 }
1034 return AUDIO_HAL_SUCCESS;
1035 }
1036
1037 /**************************public************************/
HdiServiceGetFuncs()1038 int32_t HdiServiceGetFuncs()
1039 {
1040 AUDIO_FUNC_LOGD("enter");
1041 if (g_serverManager != NULL) {
1042 return AUDIO_HAL_SUCCESS;
1043 }
1044 g_serverManager = GetAudioManagerFuncs();
1045 if (g_serverManager == NULL) {
1046 AUDIO_FUNC_LOGE("GetAudioManagerFuncs FAIL!");
1047 return AUDIO_HAL_ERR_INTERNAL;
1048 }
1049 AUDIO_FUNC_LOGD("end");
1050 return AUDIO_HAL_SUCCESS;
1051 }
1052
HdiServiceGetAllAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1053 int32_t HdiServiceGetAllAdapter(const struct HdfDeviceIoClient *client,
1054 struct HdfSBuf *data, struct HdfSBuf *reply)
1055 {
1056 if (client == NULL || data == NULL || reply == NULL) {
1057 return AUDIO_HAL_ERR_INVALID_PARAM;
1058 }
1059 static bool getAdaptersFlag = true;
1060 struct AudioAdapterDescriptor *descs = NULL;
1061 struct AudioManager *manager = g_serverManager;
1062 int32_t size = 0;
1063
1064 if (manager == NULL) {
1065 AUDIO_FUNC_LOGE("Manager is NULL");
1066 return AUDIO_HAL_ERR_INVALID_PARAM;
1067 }
1068 int32_t ret = manager->GetAllAdapters(manager, &descs, &size);
1069 if (ret < 0) {
1070 AUDIO_FUNC_LOGE("g_manager->GetAllAdapters error");
1071 return AUDIO_HAL_ERR_INTERNAL;
1072 }
1073 if (size > MAX_AUDIO_ADAPTER_NUM_SERVER || size == 0 || descs == NULL) {
1074 AUDIO_FUNC_LOGE("size or g_descs is error");
1075 return AUDIO_HAL_ERR_NOT_SUPPORT;
1076 }
1077 AudioSetFuzzCheckFlag(false);
1078 g_descs = descs;
1079 if (getAdaptersFlag) { // Initialize only once
1080 ret = AdaptersServerManageInit(descs, size);
1081 if (ret != AUDIO_HAL_SUCCESS) {
1082 AUDIO_FUNC_LOGE("AdapterServerManageInit fail");
1083 return ret;
1084 }
1085 getAdaptersFlag = false;
1086 }
1087 return AUDIO_HAL_SUCCESS;
1088 }
1089
SwitchAdapter(struct AudioAdapterDescriptor * descs,const char * adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort * renderPort,const int size)1090 static int SwitchAdapter(struct AudioAdapterDescriptor *descs, const char *adapterNameCase,
1091 enum AudioPortDirection portFlag, struct AudioPort *renderPort, const int size)
1092 {
1093 if (descs == NULL || adapterNameCase == NULL || renderPort == NULL) {
1094 return HDF_FAILURE;
1095 }
1096 for (int index = 0; index < size; index++) {
1097 struct AudioAdapterDescriptor *desc = &descs[index];
1098 if (desc == NULL) {
1099 continue;
1100 }
1101 if (desc->adapterName == NULL) {
1102 return HDF_FAILURE;
1103 }
1104 if (strcmp(desc->adapterName, adapterNameCase) != 0) {
1105 continue;
1106 }
1107 for (uint32_t port = 0; port < desc->portNum; port++) {
1108 if (desc->ports[port].dir == portFlag) {
1109 *renderPort = desc->ports[port];
1110 AUDIO_FUNC_LOGI("portFlag=%{public}d index=%{public}d success!", portFlag, index);
1111 return index;
1112 }
1113 }
1114 }
1115 AUDIO_FUNC_LOGE("out! adapterNameCase=%{public}s", adapterNameCase);
1116 return HDF_FAILURE;
1117 }
1118
1119 /* Adapter Check */
1120 static enum AudioServerType g_loadServerFlag = AUDIO_SERVER_BOTTOM;
AudioHdiGetLoadServerFlag(void)1121 enum AudioServerType AudioHdiGetLoadServerFlag(void)
1122 {
1123 return g_loadServerFlag;
1124 }
1125
AudioHdiSetLoadServerFlag(enum AudioServerType serverType)1126 void AudioHdiSetLoadServerFlag(enum AudioServerType serverType)
1127 {
1128 g_loadServerFlag = serverType;
1129 }
1130
AudioHdiClearLoadServerFlag(void)1131 void AudioHdiClearLoadServerFlag(void)
1132 {
1133 g_loadServerFlag = AUDIO_SERVER_BOTTOM;
1134 }
1135
MatchAppropriateAdapter(enum AudioAdapterType adapterType)1136 static int32_t MatchAppropriateAdapter(enum AudioAdapterType adapterType)
1137 {
1138 switch (adapterType) {
1139 case AUDIO_ADAPTER_PRIMARY:
1140 case AUDIO_ADAPTER_PRIMARY_EXT:
1141 if (AudioHdiGetLoadServerFlag() != AUDIO_SERVER_PRIMARY) {
1142 AUDIO_FUNC_LOGE("Can't loadAdapterPrimary.");
1143 return AUDIO_HAL_ERR_INTERNAL;
1144 }
1145 break;
1146 case AUDIO_ADAPTER_USB:
1147 if (AudioHdiGetLoadServerFlag() != AUDIO_SERVER_USB) {
1148 AUDIO_FUNC_LOGE("Can't loadAdapterUsb.");
1149 return AUDIO_HAL_ERR_INTERNAL;
1150 }
1151 break;
1152 case AUDIO_ADAPTER_A2DP:
1153 if (AudioHdiGetLoadServerFlag() != AUDIO_SERVER_A2DP) {
1154 AUDIO_FUNC_LOGE("Can't loadAdapterA2dp.");
1155 return AUDIO_HAL_ERR_INTERNAL;
1156 }
1157 break;
1158 default:
1159 AUDIO_FUNC_LOGE("An unsupported Adapter.");
1160 return AUDIO_HAL_ERR_NOT_SUPPORT;
1161 }
1162
1163 return AUDIO_HAL_SUCCESS;
1164 }
1165
AudioServiceUpateDevice(struct HdfDeviceObject * device,const char * servInfo)1166 static int AudioServiceUpateDevice(struct HdfDeviceObject *device, const char *servInfo)
1167 {
1168 if (device == NULL || servInfo == NULL) {
1169 AUDIO_FUNC_LOGE("device or servInfo is null!");
1170 return AUDIO_HAL_ERR_INVALID_PARAM;
1171 }
1172 if (HdfDeviceObjectSetServInfo(device, servInfo) != HDF_SUCCESS) {
1173 AUDIO_FUNC_LOGE("HdfDeviceObjectSetServInfo failed!");
1174 return AUDIO_HAL_ERR_INTERNAL;
1175 }
1176 if (HdfDeviceObjectUpdate(device) != AUDIO_HAL_SUCCESS) {
1177 AUDIO_FUNC_LOGE("HdfDeviceObjectUpdate failed!");
1178 return AUDIO_HAL_ERR_INTERNAL;
1179 }
1180
1181 return AUDIO_HAL_SUCCESS;
1182 }
1183
AudioServiceStateChange(struct HdfDeviceObject * device,struct AudioEvent * audioSrvEvent)1184 int32_t AudioServiceStateChange(struct HdfDeviceObject *device, struct AudioEvent *audioSrvEvent)
1185 {
1186 if (device == NULL || audioSrvEvent == NULL) {
1187 AUDIO_FUNC_LOGE("device or audioSrvEvent is null!");
1188 return AUDIO_HAL_ERR_INVALID_PARAM;
1189 }
1190 g_audioEventService.eventType = audioSrvEvent->eventType;
1191 g_audioEventService.deviceType = audioSrvEvent->deviceType;
1192 char strMsg[AUDIO_PNP_MSG_LEN_MAX] = {0};
1193 int ret = snprintf_s(strMsg, AUDIO_PNP_MSG_LEN_MAX, AUDIO_PNP_MSG_LEN_MAX - 1,
1194 "EVENT_SERVICE_TYPE=0x%x;EVENT_LOAD_TYPE=0x%x;DEVICE_TYPE=0x%x",
1195 g_audioEventService.eventType,
1196 g_audioEventLoad.eventType,
1197 g_audioEventService.deviceType);
1198 if (ret >= 0) {
1199 if (AudioServiceUpateDevice(device, (const char *)strMsg) != AUDIO_HAL_SUCCESS) {
1200 AUDIO_FUNC_LOGE("AudioServiceUpate fail!");
1201 return AUDIO_HAL_ERR_INTERNAL;
1202 }
1203 }
1204 return AUDIO_HAL_SUCCESS;
1205 }
1206
AudioLoadStateChange(struct HdfDeviceObject * device,struct AudioEvent * audioLoadEvent)1207 static int32_t AudioLoadStateChange(struct HdfDeviceObject *device, struct AudioEvent *audioLoadEvent)
1208 {
1209 if (device == NULL || audioLoadEvent == NULL) {
1210 AUDIO_FUNC_LOGE("device or audioLoadEvent is null!");
1211 return AUDIO_HAL_ERR_INVALID_PARAM;
1212 }
1213 g_audioEventLoad.eventType = audioLoadEvent->eventType;
1214 g_audioEventLoad.deviceType = audioLoadEvent->deviceType;
1215 char strMsg[AUDIO_PNP_MSG_LEN_MAX] = {0};
1216 int ret = snprintf_s(strMsg, AUDIO_PNP_MSG_LEN_MAX, AUDIO_PNP_MSG_LEN_MAX - 1,
1217 "EVENT_SERVICE_TYPE=0x%x;EVENT_LOAD_TYPE=0x%x;DEVICE_TYPE=0x%x",
1218 g_audioEventService.eventType,
1219 g_audioEventLoad.eventType,
1220 g_audioEventLoad.deviceType);
1221 if (ret >= 0) {
1222 if (AudioServiceUpateDevice(device, (const char *)strMsg) != AUDIO_HAL_SUCCESS) {
1223 AUDIO_FUNC_LOGE("AudioLoadUpate fail!");
1224 return AUDIO_HAL_ERR_INTERNAL;
1225 }
1226 }
1227 return AUDIO_HAL_SUCCESS;
1228 }
1229
HdiServiceDevOnLine(struct HdfDeviceObject * device,struct AudioManager * manager,const struct AudioAdapterDescriptor * desc,struct AudioAdapter ** adapter,const char * adapterName)1230 static int32_t HdiServiceDevOnLine(struct HdfDeviceObject *device, struct AudioManager *manager,
1231 const struct AudioAdapterDescriptor *desc, struct AudioAdapter **adapter, const char* adapterName)
1232 {
1233 if (device == NULL || manager == NULL || desc == NULL || adapter == NULL || adapterName == NULL) {
1234 AUDIO_FUNC_LOGE("param is null!");
1235 return AUDIO_HAL_ERR_INVALID_PARAM;
1236 }
1237 int32_t ret = manager->LoadAdapter(manager, desc, adapter);
1238 if (ret < 0) {
1239 g_audioEventLoad.eventType = HDF_AUDIO_LOAD_FAILURE;
1240 } else {
1241 g_audioEventLoad.eventType = HDF_AUDIO_LOAD_SUCCESS;
1242 }
1243 if (AudioLoadStateChange(device, &g_audioEventLoad) != AUDIO_HAL_SUCCESS) {
1244 AUDIO_FUNC_LOGE("AudioLoadStateChange fail!");
1245 }
1246 if (*adapter == NULL) {
1247 AUDIO_FUNC_LOGE("load audio device failed");
1248 return AUDIO_HAL_ERR_INVALID_PARAM;
1249 }
1250 if (AudioAdapterListAdd(adapterName, *adapter)) {
1251 AUDIO_FUNC_LOGE("AudioAdapterListAdd error!");
1252 manager->UnloadAdapter(manager, *adapter);
1253 return AUDIO_HAL_ERR_INTERNAL;
1254 }
1255 return AUDIO_HAL_SUCCESS;
1256 }
1257
HdiServiceDevOffLine(struct HdfDeviceObject * device)1258 static int32_t HdiServiceDevOffLine(struct HdfDeviceObject *device)
1259 {
1260 if (device == NULL) {
1261 AUDIO_FUNC_LOGE("device is null!");
1262 return AUDIO_HAL_ERR_INVALID_PARAM;
1263 }
1264 g_audioEventLoad.eventType = HDF_AUDIO_LOAD_FAILURE;
1265 if (AudioLoadStateChange(device, &g_audioEventLoad) != AUDIO_HAL_SUCCESS) {
1266 AUDIO_FUNC_LOGE("AudioLoadStateChange fail!");
1267 return AUDIO_HAL_ERR_INTERNAL;
1268 }
1269 return AUDIO_HAL_SUCCESS;
1270 }
1271
HdiServiceLoadAdapterSubUsb(struct HdfDeviceObject * device,struct AudioManager * manager,const struct AudioAdapterDescriptor * desc,struct AudioAdapter ** adapter,const char * adapterName)1272 static int32_t HdiServiceLoadAdapterSubUsb(struct HdfDeviceObject *device, struct AudioManager *manager,
1273 const struct AudioAdapterDescriptor *desc, struct AudioAdapter **adapter, const char* adapterName)
1274 {
1275 if (device == NULL || manager == NULL || desc == NULL || adapter == NULL || adapterName == NULL) {
1276 AUDIO_FUNC_LOGE("param is null!");
1277 return AUDIO_HAL_ERR_INVALID_PARAM;
1278 }
1279
1280 if (g_audioEventPnp.eventType == HDF_AUDIO_DEVICE_REMOVE || g_audioEventPnp.eventType == HDF_AUDIO_EVENT_UNKOWN) {
1281 HdiServiceDevOffLine(device);
1282 AUDIO_FUNC_LOGE("eventType=0x%{public}x", g_audioEventPnp.eventType);
1283 return AUDIO_HAL_ERR_NOT_SUPPORT;
1284 } else if (g_audioEventPnp.eventType == HDF_AUDIO_DEVICE_ADD) {
1285 return HdiServiceDevOnLine(device, manager, desc, adapter, adapterName);
1286 } else {
1287 AUDIO_FUNC_LOGE("eventType=0x%{public}x nothing", g_audioEventPnp.eventType);
1288 return AUDIO_HAL_ERR_INTERNAL;
1289 }
1290 }
1291
HdiServiceLoadAdapterSub(struct HdfDeviceObject * device,struct AudioManager * manager,const struct AudioAdapterDescriptor * desc,struct AudioAdapter ** adapter,const char * adapterName)1292 static int32_t HdiServiceLoadAdapterSub(struct HdfDeviceObject *device, struct AudioManager *manager,
1293 const struct AudioAdapterDescriptor *desc, struct AudioAdapter **adapter, const char* adapterName)
1294 {
1295 AUDIO_FUNC_LOGD("enter");
1296 if (device == NULL || manager == NULL || desc == NULL || adapter == NULL || adapterName == NULL) {
1297 AUDIO_FUNC_LOGE("param is null!");
1298 return AUDIO_HAL_ERR_INVALID_PARAM;
1299 }
1300 enum AudioAdapterType sndCardType = MatchAdapterType(adapterName, desc->ports[0].portId);
1301 int32_t ret = MatchAppropriateAdapter(sndCardType);
1302 if (ret != AUDIO_HAL_SUCCESS) {
1303 AUDIO_FUNC_LOGE("load audio device not matched");
1304 return AUDIO_HAL_ERR_INTERNAL;
1305 }
1306 switch (sndCardType) {
1307 case AUDIO_ADAPTER_PRIMARY:
1308 case AUDIO_ADAPTER_PRIMARY_EXT:
1309 g_audioEventService.eventType = HDF_AUDIO_SERVICE_VALID;
1310 g_audioEventLoad.deviceType = HDF_AUDIO_PRIMARY_DEVICE;
1311 return HdiServiceDevOnLine(device, manager, desc, adapter, adapterName);
1312 case AUDIO_ADAPTER_USB:
1313 g_audioEventLoad.deviceType = HDF_AUDIO_USB_DEVICE;
1314 return HdiServiceLoadAdapterSubUsb(device, manager, desc, adapter, adapterName);
1315 case AUDIO_ADAPTER_A2DP:
1316 return AUDIO_HAL_ERR_NOT_SUPPORT;
1317 default:
1318 return AUDIO_HAL_ERR_NOT_SUPPORT;
1319 }
1320 }
1321
HdiServiceLoadAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1322 int32_t HdiServiceLoadAdapter(const struct HdfDeviceIoClient *client,
1323 struct HdfSBuf *data, struct HdfSBuf *reply)
1324 {
1325 AUDIO_FUNC_LOGD("enter");
1326 if (client == NULL || data == NULL || reply == NULL) {
1327 return AUDIO_HAL_ERR_INVALID_PARAM;
1328 }
1329 struct AudioAdapter *adapter = NULL;
1330 struct AudioPort renderPort;
1331 const char *adapterName = NULL;
1332 uint32_t tempDir = 0;
1333 if ((adapterName = HdfSbufReadString(data)) == NULL) {
1334 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1335 return AUDIO_HAL_ERR_INVALID_PARAM;
1336 }
1337 int32_t ret = AudioAdapterCheckListExist(adapterName);
1338 if (ret == AUDIO_HAL_ERR_INVALID_PARAM) {
1339 return AUDIO_HAL_ERR_INTERNAL;
1340 }
1341 if (ret == AUDIO_HAL_SUCCESS) {
1342 AUDIO_FUNC_LOGE("adapte[%{public}s] already exist !", adapterName);
1343 return AUDIO_HAL_SUCCESS;
1344 }
1345 if (!HdfSbufReadUint32(data, &tempDir)) {
1346 AUDIO_FUNC_LOGE("adapter need Load!");
1347 return AUDIO_HAL_ERR_INTERNAL;
1348 }
1349 enum AudioPortDirection port = (enum AudioPortDirection)tempDir;
1350 struct AudioManager *manager = g_serverManager;
1351 if (adapterName == NULL || manager == NULL || g_descs == NULL) {
1352 AUDIO_FUNC_LOGE("Point is NULL!");
1353 return AUDIO_HAL_ERR_INTERNAL;
1354 }
1355 int index = SwitchAdapter(g_descs, adapterName, port,
1356 &renderPort, ServerManageGetAdapterNum());
1357 if (index < 0) {
1358 return AUDIO_HAL_ERR_NOT_SUPPORT;
1359 }
1360 struct AudioAdapterDescriptor *desc = &g_descs[index];
1361 ret = HdiServiceLoadAdapterSub(client->device, manager, desc, &adapter, adapterName);
1362 return ret;
1363 }
1364
HdiServiceInitAllPorts(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1365 int32_t HdiServiceInitAllPorts(const struct HdfDeviceIoClient *client,
1366 struct HdfSBuf *data, struct HdfSBuf *reply)
1367 {
1368 if (client == NULL || data == NULL || reply == NULL) {
1369 return AUDIO_HAL_ERR_INVALID_PARAM;
1370 }
1371 const char *adapterName = NULL;
1372 struct AudioAdapter *adapter = NULL;
1373 if ((adapterName = HdfSbufReadString(data)) == NULL) {
1374 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1375 return AUDIO_HAL_ERR_INVALID_PARAM;
1376 }
1377 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1378 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1379 return AUDIO_HAL_ERR_INTERNAL;
1380 }
1381 if (adapter == NULL) {
1382 AUDIO_FUNC_LOGE("adapter is NULL");
1383 return AUDIO_HAL_ERR_INTERNAL;
1384 }
1385 if (adapter->InitAllPorts(adapter)) {
1386 AUDIO_FUNC_LOGE("InitAllPorts fail");
1387 return AUDIO_HAL_ERR_INTERNAL;
1388 }
1389 return AUDIO_HAL_SUCCESS;
1390 }
1391
HdiServiceUnloadAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1392 int32_t HdiServiceUnloadAdapter(const struct HdfDeviceIoClient *client,
1393 struct HdfSBuf *data, struct HdfSBuf *reply)
1394 {
1395 if (client == NULL || data == NULL || reply == NULL) {
1396 return AUDIO_HAL_ERR_INVALID_PARAM;
1397 }
1398 struct AudioAdapter *adapter = NULL;
1399 const char *adapterName = NULL;
1400 int ret;
1401 struct AudioManager *manager = g_serverManager;
1402 if (manager == NULL) {
1403 AUDIO_FUNC_LOGE("Point is NULL!");
1404 return AUDIO_HAL_ERR_INVALID_PARAM;
1405 }
1406 if ((adapterName = HdfSbufReadString(data)) == NULL) {
1407 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1408 return AUDIO_HAL_ERR_INVALID_PARAM;
1409 }
1410 ret = AudioAdapterListDestory(adapterName, &adapter);
1411 if (ret == AUDIO_HAL_ERR_INTERNAL) {
1412 AUDIO_FUNC_LOGI("Other dev Use the adapter");
1413 return AUDIO_HAL_SUCCESS;
1414 } else if (ret == AUDIO_HAL_ERR_INVALID_PARAM) {
1415 AUDIO_FUNC_LOGE("param invalid!");
1416 return AUDIO_HAL_ERR_INTERNAL;
1417 }
1418 if (adapter == NULL) {
1419 return AUDIO_HAL_ERR_INVALID_PARAM;
1420 }
1421 manager->UnloadAdapter(manager, adapter);
1422 g_audioEventLoad.eventType = HDF_AUDIO_UNLOAD;
1423 if (AudioLoadStateChange(client->device, &g_audioEventLoad) != AUDIO_HAL_SUCCESS) {
1424 AUDIO_FUNC_LOGE("AudioLoadStateChange fail!");
1425 }
1426 AUDIO_FUNC_LOGI("Unload the adapter success!");
1427 return AUDIO_HAL_SUCCESS;
1428 }
1429
HdiServiceGetPortCapability(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1430 int32_t HdiServiceGetPortCapability(const struct HdfDeviceIoClient *client,
1431 struct HdfSBuf *data, struct HdfSBuf *reply)
1432 {
1433 if (client == NULL || data == NULL || reply == NULL) {
1434 return AUDIO_HAL_ERR_INVALID_PARAM;
1435 }
1436 struct AudioPort port;
1437 struct AudioPortCapability capability;
1438 struct AudioAdapter *adapter = NULL;
1439 const char *adapterName = NULL;
1440 uint32_t tempDir = 0;
1441 if ((adapterName = HdfSbufReadString(data)) == NULL) {
1442 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1443 return AUDIO_HAL_ERR_INVALID_PARAM;
1444 }
1445 if (!HdfSbufReadUint32(data, &tempDir)) {
1446 return AUDIO_HAL_ERR_INTERNAL;
1447 }
1448 port.dir = (enum AudioPortDirection)tempDir;
1449 if (!HdfSbufReadUint32(data, &port.portId)) {
1450 return AUDIO_HAL_ERR_INTERNAL;
1451 }
1452 if ((port.portName = HdfSbufReadString(data)) == NULL) {
1453 return AUDIO_HAL_ERR_INTERNAL;
1454 }
1455 AUDIO_FUNC_LOGD("port.portName = %{public}s", port.portName);
1456 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1457 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1458 return AUDIO_HAL_ERR_INTERNAL;
1459 }
1460 if (adapter == NULL) {
1461 AUDIO_FUNC_LOGE("HdiServiceCreatRender adapter is NULL!");
1462 return AUDIO_HAL_ERR_INVALID_PARAM;
1463 }
1464 if (adapter->GetPortCapability == NULL) {
1465 AUDIO_FUNC_LOGE("GetPortCapability is NULL");
1466 return AUDIO_HAL_ERR_INTERNAL;
1467 }
1468 int32_t ret = adapter->GetPortCapability(adapter, &port, &capability);
1469 if (ret < 0) {
1470 AUDIO_FUNC_LOGE("GetPortCapability failed ret = %{public}d", ret);
1471 return AUDIO_HAL_ERR_INTERNAL;
1472 }
1473 return AUDIO_HAL_SUCCESS;
1474 }
1475
HdiServiceSetPassthroughMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1476 int32_t HdiServiceSetPassthroughMode(const struct HdfDeviceIoClient *client,
1477 struct HdfSBuf *data, struct HdfSBuf *reply)
1478 {
1479 if (client == NULL || data == NULL || reply == NULL) {
1480 return AUDIO_HAL_ERR_INVALID_PARAM;
1481 }
1482 struct AudioPort port;
1483 enum AudioPortPassthroughMode mode;
1484 struct AudioAdapter *adapter = NULL;
1485 const char *adapterName = NULL;
1486 if ((adapterName = HdfSbufReadString(data)) == NULL) {
1487 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1488 return AUDIO_HAL_ERR_INVALID_PARAM;
1489 }
1490 uint32_t tempDir = 0;
1491 if (!HdfSbufReadUint32(data, &tempDir)) {
1492 return AUDIO_HAL_ERR_INTERNAL;
1493 }
1494 port.dir = (enum AudioPortDirection)tempDir;
1495 AUDIO_FUNC_LOGD("port.dir = %{public}d", port.dir);
1496 if (!HdfSbufReadUint32(data, &port.portId)) {
1497 return AUDIO_HAL_ERR_INTERNAL;
1498 }
1499 if ((port.portName = HdfSbufReadString(data)) == NULL) {
1500 AUDIO_FUNC_LOGE("port.portName = %{public}s", port.portName);
1501 return AUDIO_HAL_ERR_INTERNAL;
1502 }
1503 AUDIO_FUNC_LOGD("port.portName = %{public}s", port.portName);
1504 uint32_t tempMode = 0;
1505 if (!HdfSbufReadUint32(data, &tempMode)) {
1506 return AUDIO_HAL_ERR_INTERNAL;
1507 }
1508 mode = (enum AudioPortPassthroughMode)tempMode;
1509 AUDIO_FUNC_LOGD("ready in, mode = %{public}d", mode);
1510 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1511 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1512 return AUDIO_HAL_ERR_INTERNAL;
1513 }
1514 if (adapter == NULL) {
1515 AUDIO_FUNC_LOGE("HdiServiceCreatRender adapter is NULL!");
1516 return AUDIO_HAL_ERR_INVALID_PARAM;
1517 }
1518 if (adapter->SetPassthroughMode == NULL) {
1519 AUDIO_FUNC_LOGE("SetPassthroughMode is NULL");
1520 return AUDIO_HAL_ERR_INTERNAL;
1521 }
1522 int ret = adapter->SetPassthroughMode(adapter, &port, mode);
1523 return ret;
1524 }
1525
HdiServiceGetPassthroughMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1526 int32_t HdiServiceGetPassthroughMode(const struct HdfDeviceIoClient *client,
1527 struct HdfSBuf *data, struct HdfSBuf *reply)
1528 {
1529 if (client == NULL || data == NULL || reply == NULL) {
1530 return AUDIO_HAL_ERR_INVALID_PARAM;
1531 }
1532 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
1533 struct AudioAdapter *adapter = NULL;
1534 const char *adapterName = NULL;
1535 struct AudioPort port;
1536 int32_t ret = memset_s(&port, sizeof(struct AudioPort), 0, sizeof(struct AudioPort));
1537 if (ret != HDF_SUCCESS) {
1538 AUDIO_FUNC_LOGE("memset_s failed");
1539 return AUDIO_HAL_ERR_INTERNAL;
1540 }
1541 if ((adapterName = HdfSbufReadString(data)) == NULL) {
1542 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1543 return AUDIO_HAL_ERR_INVALID_PARAM;
1544 }
1545 uint32_t tempDir = port.dir;
1546 if (!HdfSbufReadUint32(data, &tempDir)) {
1547 return AUDIO_HAL_ERR_INTERNAL;
1548 }
1549 port.dir = (enum AudioPortDirection)tempDir;
1550 if (!HdfSbufReadUint32(data, &port.portId)) {
1551 return AUDIO_HAL_ERR_INTERNAL;
1552 }
1553 if ((port.portName = HdfSbufReadString(data)) == NULL) {
1554 AUDIO_FUNC_LOGE("port.portName = %{public}s", port.portName);
1555 return AUDIO_HAL_ERR_INTERNAL;
1556 }
1557 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1558 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1559 return AUDIO_HAL_ERR_INTERNAL;
1560 }
1561 if (adapter == NULL) {
1562 AUDIO_FUNC_LOGE("adapter is NULL!");
1563 return AUDIO_HAL_ERR_INVALID_PARAM;
1564 }
1565 if (adapter->GetPassthroughMode == NULL) {
1566 AUDIO_FUNC_LOGE("GetPassthroughMode is NULL");
1567 return AUDIO_HAL_ERR_INTERNAL;
1568 }
1569 ret = adapter->GetPassthroughMode(adapter, &port, &mode);
1570 if (ret < 0) {
1571 AUDIO_FUNC_LOGE("GetPassthroughMode ret failed");
1572 return AUDIO_HAL_ERR_INTERNAL;
1573 }
1574 uint32_t tempMode = (uint32_t)mode;
1575 if (!HdfSbufWriteUint32(reply, tempMode)) {
1576 return AUDIO_HAL_ERR_INTERNAL;
1577 }
1578 return AUDIO_HAL_SUCCESS;
1579 }
1580
HdiServiceGetDevStatusByPnp(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1581 static int32_t HdiServiceGetDevStatusByPnp(const struct HdfDeviceIoClient *client,
1582 struct HdfSBuf *data, struct HdfSBuf *reply)
1583 {
1584 (void)reply;
1585 const char *strDevPlugMsg = NULL;
1586 if (client == NULL || data == NULL) {
1587 AUDIO_FUNC_LOGE("client or data is null!");
1588 return AUDIO_HAL_ERR_INVALID_PARAM;
1589 }
1590 if ((strDevPlugMsg = HdfSbufReadString(data)) == NULL) {
1591 AUDIO_FUNC_LOGE("data is null!");
1592 return AUDIO_HAL_ERR_INTERNAL;
1593 }
1594
1595 if ((AudioPnpMsgReadValue(strDevPlugMsg, "EVENT_TYPE", &(g_audioEventPnp.eventType)) != HDF_SUCCESS) ||
1596 (AudioPnpMsgReadValue(strDevPlugMsg, "DEVICE_TYPE", &(g_audioEventPnp.deviceType)) != HDF_SUCCESS)) {
1597 AUDIO_FUNC_LOGE("DeSerialize fail!");
1598 return AUDIO_HAL_ERR_INTERNAL;
1599 }
1600 if (g_audioEventPnp.deviceType == HDF_AUDIO_USB_HEADSET ||
1601 g_audioEventPnp.deviceType == HDF_AUDIO_USB_HEADPHONE ||
1602 g_audioEventPnp.deviceType == HDF_AUDIO_USBA_HEADSET ||
1603 g_audioEventPnp.deviceType == HDF_AUDIO_USBA_HEADPHONE) {
1604 g_audioEventService.deviceType = HDF_AUDIO_USB_DEVICE;
1605 if (g_audioEventPnp.eventType == HDF_AUDIO_DEVICE_ADD) {
1606 g_audioEventService.eventType = HDF_AUDIO_SERVICE_VALID;
1607 } else if (g_audioEventPnp.eventType == HDF_AUDIO_DEVICE_REMOVE) {
1608 g_audioEventService.eventType = HDF_AUDIO_SERVICE_INVALID;
1609 }
1610 }
1611 if (AudioServiceStateChange(client->device, &g_audioEventService) != AUDIO_HAL_SUCCESS) {
1612 AUDIO_FUNC_LOGE("AudioServiceStateChange fail!");
1613 return AUDIO_HAL_ERR_INTERNAL;
1614 }
1615 return AUDIO_HAL_SUCCESS;
1616 }
1617
AudioDevExtInfoBlockUnmarshalling(struct HdfSBuf * data,struct AudioDevExtInfo * dataBlock)1618 static bool AudioDevExtInfoBlockUnmarshalling(struct HdfSBuf *data, struct AudioDevExtInfo *dataBlock)
1619 {
1620 if (data == NULL || dataBlock == NULL) {
1621 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1622 goto ERROR;
1623 }
1624
1625 if (!HdfSbufReadInt32(data, &dataBlock->moduleId)) {
1626 HDF_LOGE("%{public}s: read dataBlock->moduleId failed!", __func__);
1627 goto ERROR;
1628 }
1629
1630 if (!HdfSbufReadInt32(data, (int32_t*)&dataBlock->type)) {
1631 HDF_LOGE("%{public}s: read dataBlock->type failed!", __func__);
1632 goto ERROR;
1633 }
1634
1635 const char *descCp = HdfSbufReadString(data);
1636 if (descCp == NULL) {
1637 HDF_LOGE("%{public}s: read descCp failed!", __func__);
1638 goto ERROR;
1639 }
1640
1641 dataBlock->desc = strdup(descCp);
1642 if (dataBlock->desc == NULL) {
1643 HDF_LOGE("strdup fail in %{public}s", __func__);
1644 goto ERROR;
1645 }
1646
1647 return true;
1648 ERROR:
1649 if (dataBlock->desc != NULL) {
1650 OsalMemFree((void*)dataBlock->desc);
1651 dataBlock->desc = NULL;
1652 }
1653
1654 return false;
1655 }
1656
AudioMixExtInfoBlockUnmarshalling(struct HdfSBuf * data,struct AudioMixExtInfo * dataBlock)1657 static bool AudioMixExtInfoBlockUnmarshalling(struct HdfSBuf *data, struct AudioMixExtInfo *dataBlock)
1658 {
1659 if (data == NULL || dataBlock == NULL) {
1660 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1661 return false;
1662 }
1663
1664 const struct AudioMixExtInfo *dataBlockPtr = (const struct AudioMixExtInfo *)HdfSbufReadUnpadBuffer(data,
1665 sizeof(struct AudioMixExtInfo));
1666 if (dataBlockPtr == NULL) {
1667 HDF_LOGE("%{public}s: failed to read buffer data", __func__);
1668 return false;
1669 }
1670
1671 if (memcpy_s(dataBlock, sizeof(struct AudioMixExtInfo), dataBlockPtr, sizeof(struct AudioMixExtInfo)) != EOK) {
1672 HDF_LOGE("%{public}s: failed to memcpy data", __func__);
1673 return false;
1674 }
1675
1676 return true;
1677 }
1678
AudioSessionExtInfoBlockUnmarshalling(struct HdfSBuf * data,struct AudioSessionExtInfo * dataBlock)1679 static bool AudioSessionExtInfoBlockUnmarshalling(struct HdfSBuf *data, struct AudioSessionExtInfo *dataBlock)
1680 {
1681 if (data == NULL || dataBlock == NULL) {
1682 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1683 return false;
1684 }
1685
1686 const struct AudioSessionExtInfo *dataBlockPtr = (const struct AudioSessionExtInfo *)HdfSbufReadUnpadBuffer(data,
1687 sizeof(struct AudioSessionExtInfo));
1688 if (dataBlockPtr == NULL) {
1689 HDF_LOGE("%{public}s: failed to read buffer data", __func__);
1690 return false;
1691 }
1692
1693 if (memcpy_s(dataBlock, sizeof(struct AudioSessionExtInfo), dataBlockPtr,
1694 sizeof(struct AudioSessionExtInfo)) != EOK) {
1695 HDF_LOGE("%{public}s: failed to memcpy data", __func__);
1696 return false;
1697 }
1698
1699 return true;
1700 }
1701
AudioDevExtInfoFree(struct AudioDevExtInfo * dataBlock,bool freeSelf)1702 static void AudioDevExtInfoFree(struct AudioDevExtInfo *dataBlock, bool freeSelf)
1703 {
1704 if (dataBlock == NULL) {
1705 return;
1706 }
1707
1708 if (dataBlock->desc != NULL) {
1709 OsalMemFree((void*)dataBlock->desc);
1710 dataBlock->desc = NULL;
1711 }
1712
1713 if (freeSelf) {
1714 OsalMemFree(dataBlock);
1715 }
1716 }
1717
AudioInfoBlockUnmarshalling(enum AudioPortType type,struct HdfSBuf * data,RouteExtInfo * dataBlock)1718 static inline bool AudioInfoBlockUnmarshalling(enum AudioPortType type, struct HdfSBuf *data, RouteExtInfo *dataBlock)
1719 {
1720 if (data == NULL || dataBlock == NULL) {
1721 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1722 return false;
1723 }
1724 bool ret = true;
1725 switch (type) {
1726 case AUDIO_PORT_DEVICE_TYPE:
1727 if (!AudioDevExtInfoBlockUnmarshalling(data, &dataBlock->device)) {
1728 HDF_LOGE("%{public}s: write dataBlock->device failed!", __func__);
1729 AudioDevExtInfoFree(&dataBlock->device, false);
1730 ret = false;
1731 }
1732 break;
1733 case AUDIO_PORT_MIX_TYPE:
1734 if (!AudioMixExtInfoBlockUnmarshalling(data, &dataBlock->mix)) {
1735 HDF_LOGE("%{public}s: write dataBlock->mix failed!", __func__);
1736 ret = false;
1737 }
1738 break;
1739 case AUDIO_PORT_SESSION_TYPE:
1740 if (!AudioSessionExtInfoBlockUnmarshalling(data, &dataBlock->session)) {
1741 HDF_LOGE("%{public}s: write dataBlock->session failed!", __func__);
1742 ret = false;
1743 }
1744 break;
1745 case AUDIO_PORT_UNASSIGNED_TYPE:
1746 default:
1747 ret = false;
1748 break;
1749 }
1750
1751 return ret;
1752 }
1753
AudioRouteNodeBlockUnmarshalling(struct HdfSBuf * data,struct AudioRouteNode * dataBlock)1754 static bool AudioRouteNodeBlockUnmarshalling(struct HdfSBuf *data, struct AudioRouteNode *dataBlock)
1755 {
1756 if (data == NULL || dataBlock == NULL) {
1757 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1758 return false;
1759 }
1760
1761 if (!HdfSbufReadInt32(data, &dataBlock->portId)) {
1762 HDF_LOGE("%{public}s: read dataBlock->portId failed!", __func__);
1763 return false;
1764 }
1765
1766 if (!HdfSbufReadInt32(data, (int32_t*)&dataBlock->role)) {
1767 HDF_LOGE("%{public}s: read dataBlock->role failed!", __func__);
1768 return false;
1769 }
1770
1771 if (!HdfSbufReadInt32(data, (int32_t*)&dataBlock->type)) {
1772 HDF_LOGE("%{public}s: read dataBlock->type failed!", __func__);
1773 return false;
1774 }
1775
1776 if (!AudioInfoBlockUnmarshalling(dataBlock->type, data, (RouteExtInfo*)&dataBlock->ext)) {
1777 HDF_LOGE("%{public}s: read &dataBlock->ext failed!", __func__);
1778 return false;
1779 }
1780
1781 return true;
1782 }
1783
AudioRouteBlockUnmarshalling(struct HdfSBuf * data,struct AudioRoute * dataBlock)1784 static bool AudioRouteBlockUnmarshalling(struct HdfSBuf *data, struct AudioRoute *dataBlock)
1785 {
1786 if (data == NULL || dataBlock == NULL) {
1787 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
1788 return false;
1789 }
1790
1791 struct AudioRouteNode* sourcesCp = NULL;
1792 uint32_t sourcesNum = 0;
1793 struct AudioRouteNode* sinksCp = NULL;
1794 uint32_t sinksNum = 0;
1795 if (!HdfSbufReadUint32(data, &sourcesNum)) {
1796 HDF_LOGE("%{public}s: read sourcesNum failed!", __func__);
1797 return false;
1798 }
1799 if (sourcesNum > 0) {
1800 sourcesCp = (struct AudioRouteNode*)OsalMemCalloc(sizeof(struct AudioRouteNode) * sourcesNum);
1801 if (sourcesCp == NULL) {
1802 return false;
1803 }
1804 for (uint32_t i = 0; i < sourcesNum; i++) {
1805 if (!AudioRouteNodeBlockUnmarshalling(data, &sourcesCp[i])) {
1806 HDF_LOGE("%{public}s: read &sourcesCp[i] failed!", __func__);
1807 OsalMemFree((void*)sourcesCp);
1808 return false;
1809 }
1810 }
1811 }
1812 dataBlock->sources = sourcesCp;
1813 dataBlock->sourcesNum = sourcesNum;
1814
1815 if (!HdfSbufReadUint32(data, &sinksNum)) {
1816 HDF_LOGE("%{public}s: read sinksNum failed!", __func__);
1817 OsalMemFree((void*)sourcesCp);
1818 return false;
1819 }
1820 if (sinksNum > 0) {
1821 sinksCp = (struct AudioRouteNode*)OsalMemCalloc(sizeof(struct AudioRouteNode) * sinksNum);
1822 if (sinksCp == NULL) {
1823 OsalMemFree((void*)sourcesCp);
1824 return false;
1825 }
1826 for (uint32_t i = 0; i < sinksNum; i++) {
1827 if (!AudioRouteNodeBlockUnmarshalling(data, &sinksCp[i])) {
1828 HDF_LOGE("%{public}s: read &sinksCp[i] failed!", __func__);
1829 OsalMemFree((void*)sourcesCp);
1830 OsalMemFree((void*)sinksCp);
1831 return false;
1832 }
1833 }
1834 }
1835 dataBlock->sinks = sinksCp;
1836 dataBlock->sinksNum = sinksNum;
1837
1838 return true;
1839 }
1840
AudioRouteDevFreeByNum(const struct AudioRouteNode * routeNode,uint32_t num)1841 static void AudioRouteDevFreeByNum(const struct AudioRouteNode *routeNode, uint32_t num)
1842 {
1843 uint32_t nodeCnt;
1844 if (routeNode == NULL) {
1845 AUDIO_FUNC_LOGI("routeNode has been freed");
1846 return;
1847 }
1848
1849 for (nodeCnt = 0; nodeCnt < num; nodeCnt++) {
1850 if (routeNode[nodeCnt].type == AUDIO_PORT_DEVICE_TYPE) {
1851 AudioDevExtInfoFree((struct AudioDevExtInfo *)&routeNode[nodeCnt].ext.device, false);
1852 }
1853 }
1854 }
1855
AudioRouteFree(struct AudioRoute * dataBlock,bool freeSelf)1856 static void AudioRouteFree(struct AudioRoute *dataBlock, bool freeSelf)
1857 {
1858 if (dataBlock == NULL) {
1859 AUDIO_FUNC_LOGI("dataBlock has been freed");
1860 return;
1861 }
1862
1863 if (dataBlock->sources != NULL) {
1864 AudioRouteDevFreeByNum(dataBlock->sources, dataBlock->sourcesNum);
1865 OsalMemFree((void*)dataBlock->sources);
1866 }
1867
1868 if (dataBlock->sinks != NULL) {
1869 AudioRouteDevFreeByNum(dataBlock->sinks, dataBlock->sinksNum);
1870 OsalMemFree((void*)dataBlock->sinks);
1871 }
1872
1873 if (freeSelf) {
1874 OsalMemFree((void*)dataBlock);
1875 }
1876 }
1877
HdiSerStubUpdateAudioRoute(const struct HdfDeviceIoClient * client,struct HdfSBuf * audioAdapterData,struct HdfSBuf * audioAdapterReply)1878 static int32_t HdiSerStubUpdateAudioRoute(const struct HdfDeviceIoClient *client, struct HdfSBuf *audioAdapterData,
1879 struct HdfSBuf *audioAdapterReply)
1880 {
1881 int32_t audioAdapterRet = HDF_FAILURE;
1882 struct AudioRoute* route = NULL;
1883 int32_t routeHandle = 0;
1884 struct AudioAdapter *adapter = NULL;
1885 const char *adapterName = NULL;
1886
1887 if ((adapterName = HdfSbufReadString(audioAdapterData)) == NULL) {
1888 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1889 return AUDIO_HAL_ERR_INVALID_PARAM;
1890 }
1891
1892 route = (struct AudioRoute*)OsalMemAlloc(sizeof(struct AudioRoute));
1893 if (route == NULL) {
1894 HDF_LOGE("%{public}s: malloc route failed", __func__);
1895 audioAdapterRet = HDF_ERR_MALLOC_FAIL;
1896 }
1897
1898 if (!AudioRouteBlockUnmarshalling(audioAdapterData, route)) {
1899 HDF_LOGE("%{public}s: read route failed!", __func__);
1900 audioAdapterRet = HDF_ERR_INVALID_PARAM;
1901 goto FINISHED;
1902 }
1903
1904 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1905 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1906 return AUDIO_HAL_ERR_INTERNAL;
1907 }
1908 if (adapter == NULL) {
1909 AUDIO_FUNC_LOGE("adapter is NULL!");
1910 return AUDIO_HAL_ERR_INVALID_PARAM;
1911 }
1912
1913 audioAdapterRet = adapter->UpdateAudioRoute(adapter, route, &routeHandle);
1914 if (audioAdapterRet != HDF_SUCCESS) {
1915 HDF_LOGE("%{public}s: call UpdateAudioRoute function failed!", __func__);
1916 goto FINISHED;
1917 }
1918
1919 if (adapter->UpdateAudioRoute == NULL) {
1920 AUDIO_FUNC_LOGE("UpdateAudioRoute is NULL");
1921 return AUDIO_HAL_ERR_INTERNAL;
1922 }
1923 if (!HdfSbufWriteInt32(audioAdapterReply, routeHandle)) {
1924 HDF_LOGE("%{public}s: write routeHandle failed!", __func__);
1925 audioAdapterRet = HDF_ERR_INVALID_PARAM;
1926 goto FINISHED;
1927 }
1928
1929 FINISHED:
1930 if (route != NULL) {
1931 AudioRouteFree(route, true);
1932 route = NULL;
1933 }
1934 return audioAdapterRet;
1935 }
1936
HdiSerStubReleaseAudioRoute(const struct HdfDeviceIoClient * client,struct HdfSBuf * audioAdapterData,struct HdfSBuf * audioAdapterReply)1937 static int32_t HdiSerStubReleaseAudioRoute(const struct HdfDeviceIoClient *client, struct HdfSBuf *audioAdapterData,
1938 struct HdfSBuf *audioAdapterReply)
1939 {
1940 int32_t audioAdapterRet = HDF_FAILURE;
1941 int32_t routeHandle = 0;
1942 struct AudioAdapter *adapter = NULL;
1943 const char *adapterName = NULL;
1944
1945 if ((adapterName = HdfSbufReadString(audioAdapterData)) == NULL) {
1946 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
1947 return AUDIO_HAL_ERR_INVALID_PARAM;
1948 }
1949
1950 if (!HdfSbufReadInt32(audioAdapterData, &routeHandle)) {
1951 HDF_LOGE("%{public}s: read &routeHandle failed!", __func__);
1952 return HDF_ERR_INVALID_PARAM;
1953 }
1954
1955 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
1956 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1957 return AUDIO_HAL_ERR_INTERNAL;
1958 }
1959
1960 if (adapter == NULL || adapter->ReleaseAudioRoute == NULL) {
1961 AUDIO_FUNC_LOGE("adapter or ReleaseAudioRoute is NULL");
1962 return AUDIO_HAL_ERR_INTERNAL;
1963 }
1964 audioAdapterRet = adapter->ReleaseAudioRoute(adapter, routeHandle);
1965 if (audioAdapterRet != HDF_SUCCESS) {
1966 HDF_LOGE("%{public}s: call ReleaseAudioRoute function failed!", __func__);
1967 }
1968
1969 return audioAdapterRet;
1970 }
1971
HdiServiceAdapterSetMicMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)1972 static int32_t HdiServiceAdapterSetMicMute(const struct HdfDeviceIoClient *client,
1973 struct HdfSBuf *data, struct HdfSBuf *reply)
1974 {
1975 bool mute = false;
1976 uint32_t tempMute = 0;
1977 struct AudioAdapter *adapter = NULL;
1978 const char *adapterName = NULL;
1979
1980 if (client == NULL || data == NULL || reply == NULL) {
1981 AUDIO_FUNC_LOGE("client or data or reply is NULL");
1982 return AUDIO_HAL_ERR_INVALID_PARAM;
1983 }
1984
1985 if ((adapterName = HdfSbufReadString(data)) == NULL) {
1986 AUDIO_FUNC_LOGE("adapterName Is NULL ");
1987 return HDF_FAILURE;
1988 }
1989
1990 if (!HdfSbufReadUint32(data, &tempMute)) {
1991 AUDIO_FUNC_LOGE("tempMute Is NULL ");
1992 return HDF_FAILURE;
1993 }
1994 mute = (bool)tempMute;
1995
1996 if (AudioAdapterListGetAdapter(adapterName, &adapter) != HDF_SUCCESS) {
1997 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
1998 return AUDIO_HAL_ERR_INTERNAL;
1999 }
2000
2001 if (adapter == NULL || adapter->SetMicMute == NULL) {
2002 AUDIO_FUNC_LOGE("adapter or SetMicMute is NULL");
2003 return AUDIO_HAL_ERR_INTERNAL;
2004 }
2005
2006 return adapter->SetMicMute(adapter, mute);
2007 }
2008
HdiServiceAdapterGetMicMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)2009 static int32_t HdiServiceAdapterGetMicMute(const struct HdfDeviceIoClient *client,
2010 struct HdfSBuf *data, struct HdfSBuf *reply)
2011 {
2012 if (client == NULL || data == NULL || reply == NULL) {
2013 AUDIO_FUNC_LOGE("client or data or reply is NULL");
2014 return AUDIO_HAL_ERR_INVALID_PARAM;
2015 }
2016
2017 bool mute = false;
2018 struct AudioAdapter *adapter = NULL;
2019 const char *adapterName = NULL;
2020
2021 if ((adapterName = HdfSbufReadString(data)) == NULL) {
2022 AUDIO_FUNC_LOGE("adapterName Is NULL ");
2023 return HDF_FAILURE;
2024 }
2025
2026 if (AudioAdapterListGetAdapter(adapterName, &adapter) != HDF_SUCCESS) {
2027 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
2028 return AUDIO_HAL_ERR_INTERNAL;
2029 }
2030
2031 if (adapter == NULL || adapter->GetMicMute == NULL) {
2032 AUDIO_FUNC_LOGE("adapter or SetMicMute is NULL");
2033 return AUDIO_HAL_ERR_INTERNAL;
2034 }
2035
2036 int ret = adapter->GetMicMute(adapter, &mute);
2037 if (ret < 0) {
2038 AUDIO_FUNC_LOGE("GetMicMute FAIL");
2039 return ret;
2040 }
2041
2042 if (!HdfSbufWriteUint32(reply, (uint32_t)mute)) {
2043 return AUDIO_HAL_ERR_INTERNAL;
2044 }
2045
2046 return AUDIO_HAL_SUCCESS;
2047 }
2048
HdiServiceAdapterSetVoiceVolume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)2049 static int32_t HdiServiceAdapterSetVoiceVolume(const struct HdfDeviceIoClient *client,
2050 struct HdfSBuf *data, struct HdfSBuf *reply)
2051 {
2052 float volume = 0;
2053 struct AudioAdapter *adapter = NULL;
2054 const char *adapterName = NULL;
2055
2056 if (client == NULL || data == NULL || reply == NULL) {
2057 AUDIO_FUNC_LOGE("client or data or reply is NULL");
2058 return AUDIO_HAL_ERR_INVALID_PARAM;
2059 }
2060
2061 if ((adapterName = HdfSbufReadString(data)) == NULL) {
2062 AUDIO_FUNC_LOGE("adapterName Is NULL ");
2063 return HDF_FAILURE;
2064 }
2065
2066 if (!HdfSbufReadFloat(data, &volume)) {
2067 AUDIO_FUNC_LOGE("volume Is NULL ");
2068 return HDF_FAILURE;
2069 }
2070
2071 if (AudioAdapterListGetAdapter(adapterName, &adapter) != HDF_SUCCESS) {
2072 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
2073 return AUDIO_HAL_ERR_INTERNAL;
2074 }
2075
2076 if (adapter == NULL || adapter->SetVoiceVolume == NULL) {
2077 AUDIO_FUNC_LOGE("adapter or SetVoiceVolume is NULL");
2078 return AUDIO_HAL_ERR_INTERNAL;
2079 }
2080
2081 return adapter->SetVoiceVolume(adapter, volume);
2082 }
2083
HdiServiceAdapterSetExtraParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)2084 static int32_t HdiServiceAdapterSetExtraParams(const struct HdfDeviceIoClient *client,
2085 struct HdfSBuf *data, struct HdfSBuf *reply)
2086 {
2087 if (client == NULL || data == NULL || reply == NULL) {
2088 AUDIO_FUNC_LOGE("the parameter is empty");
2089 return AUDIO_HAL_ERR_INVALID_PARAM;
2090 }
2091
2092 struct AudioAdapter *adapter = NULL;
2093 const char *adapterName = NULL;
2094 const char *value = NULL;
2095 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
2096 const char *condition = NULL;
2097
2098 if ((adapterName = HdfSbufReadString(data)) == NULL) {
2099 AUDIO_FUNC_LOGE("adapterName is NULL");
2100 return HDF_FAILURE;
2101 }
2102
2103 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
2104 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter FAIL");
2105 return AUDIO_HAL_ERR_INTERNAL;
2106 }
2107
2108 value = HdfSbufReadString(data);
2109 if (value == NULL) {
2110 AUDIO_FUNC_LOGE("value is NULL");
2111 return AUDIO_HAL_ERR_INTERNAL;
2112 }
2113
2114 if (adapter == NULL || adapter->SetExtraParams == NULL) {
2115 AUDIO_FUNC_LOGE("adapter or SetExtraParams is NULL");
2116 return AUDIO_HAL_ERR_INTERNAL;
2117 }
2118
2119 return adapter->SetExtraParams(adapter, key, condition, value);
2120 }
2121
HdiServiceAdapterGetExtraParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)2122 static int32_t HdiServiceAdapterGetExtraParams(const struct HdfDeviceIoClient *client,
2123 struct HdfSBuf *data, struct HdfSBuf *reply)
2124 {
2125 if (client == NULL || data == NULL || reply == NULL) {
2126 AUDIO_FUNC_LOGE("the parameter is empty");
2127 return AUDIO_HAL_ERR_INVALID_PARAM;
2128 }
2129
2130 int32_t length = 0;
2131 struct AudioAdapter *adapter = NULL;
2132 const char *adapterName = NULL;
2133 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
2134 const char *condition = NULL;
2135 char value[STR_MAX] = { 0 };
2136
2137 if ((adapterName = HdfSbufReadString(data)) == NULL) {
2138 AUDIO_FUNC_LOGE("adapterName is NULL");
2139 return HDF_FAILURE;
2140 }
2141
2142 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
2143 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter FAIL");
2144 return AUDIO_HAL_ERR_INTERNAL;
2145 }
2146
2147 condition = HdfSbufReadString(data);
2148 if (condition == NULL) {
2149 AUDIO_FUNC_LOGE("condition is NULL");
2150 return AUDIO_HAL_ERR_INTERNAL;
2151 }
2152
2153 if (!HdfSbufReadInt32(data, &length)) {
2154 AUDIO_FUNC_LOGE("HdiServiceAdapterGetExtraParams FAIL! length is 0.");
2155 return AUDIO_HAL_ERR_INTERNAL;
2156 }
2157
2158 if (adapter == NULL || adapter->GetExtraParams == NULL) {
2159 AUDIO_FUNC_LOGE("adapter or GetExtraParams is NULL");
2160 return AUDIO_HAL_ERR_INTERNAL;
2161 }
2162
2163 int ret = adapter->GetExtraParams(adapter, key, condition, value, length);
2164 if (ret < 0) {
2165 AUDIO_FUNC_LOGE("GetExtraParams FAIL");
2166 return ret;
2167 }
2168
2169 if (!HdfSbufWriteString(reply, value)) {
2170 AUDIO_FUNC_LOGE("value write fail");
2171 return AUDIO_HAL_ERR_INTERNAL;
2172 }
2173
2174 return AUDIO_HAL_SUCCESS;
2175 }
2176
2177 struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleList[] = {
2178 {AUDIO_HDI_MGR_GET_FUNCS, HdiServiceGetFuncs},
2179 {AUDIO_HDI_MGR_GET_ALL_ADAPTER, HdiServiceGetAllAdapter},
2180 {AUDIO_HDI_MGR_LOAD_ADAPTER, HdiServiceLoadAdapter},
2181 {AUDIO_HDI_MGR_UNLOAD_ADAPTER, HdiServiceUnloadAdapter},
2182 {AUDIO_HDI_ADT_INIT_PORTS, HdiServiceInitAllPorts},
2183 {AUDIO_HDI_ADT_GET_PORT_CAPABILITY, HdiServiceGetPortCapability},
2184 {AUDIO_HDI_ADT_SET_PASS_MODE, HdiServiceSetPassthroughMode},
2185 {AUDIO_HDI_ADT_GET_PASS_MODE, HdiServiceGetPassthroughMode},
2186 {AUDIO_HDI_ADT_UPDATE_ROUTE, HdiSerStubUpdateAudioRoute},
2187 {AUDIO_HDI_ADT_RELEASE_ROUTE, HdiSerStubReleaseAudioRoute},
2188 {AUDIO_HDI_ADT_SET_MIC_MUTE, HdiServiceAdapterSetMicMute},
2189 {AUDIO_HDI_ADT_GET_MIC_MUTE, HdiServiceAdapterGetMicMute},
2190 {AUDIO_HDI_ADT_SET_VOICE_VOLUME, HdiServiceAdapterSetVoiceVolume},
2191 {AUDIO_HDI_ADT_SET_EXTRA_PARAMS, HdiServiceAdapterSetExtraParams},
2192 {AUDIO_HDI_ADT_GET_EXTRA_PARAMS, HdiServiceAdapterGetExtraParams},
2193 {AUDIO_HDI_PNP_DEV_STATUS, HdiServiceGetDevStatusByPnp},
2194 {AUDIO_HDI_RENDER_CREATE_RENDER, HdiServiceCreatRender},
2195 {AUDIO_HDI_RENDER_DESTROY, HdiServiceRenderDestory},
2196 {AUDIO_HDI_RENDER_START, HdiServiceRenderStart},
2197 {AUDIO_HDI_RENDER_STOP, HdiServiceRenderStop},
2198 {AUDIO_HDI_RENDER_PAUSE, HdiServiceRenderPause},
2199 {AUDIO_HDI_RENDER_RESUME, HdiServiceRenderResume},
2200 {AUDIO_HDI_RENDER_FLUSH, HdiServiceRenderFlush},
2201 {AUDIO_HDI_RENDER_GET_FRAME_SIZE, HdiServiceRenderGetFrameSize},
2202 {AUDIO_HDI_RENDER_GET_FRAME_COUNT, HdiServiceRenderGetFrameCount},
2203 {AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, HdiServiceRenderSetSampleAttr},
2204 {AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, HdiServiceRenderGetSampleAttr},
2205 {AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, HdiServiceRenderGetCurChannelId},
2206 {AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, HdiServiceRenderCheckSceneCapability},
2207 {AUDIO_HDI_RENDER_SELECT_SCENE, HdiServiceRenderSelectScene},
2208 {AUDIO_HDI_RENDER_GET_MUTE, HdiServiceRenderGetMute},
2209 {AUDIO_HDI_RENDER_SET_MUTE, HdiServiceRenderSetMute},
2210 {AUDIO_HDI_RENDER_SET_VOLUME, HdiServiceRenderSetVolume},
2211 {AUDIO_HDI_RENDER_GET_VOLUME, HdiServiceRenderGetVolume},
2212 {AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, HdiServiceRenderGetGainThreshold},
2213 {AUDIO_HDI_RENDER_GET_GAIN, HdiServiceRenderGetGain},
2214 {AUDIO_HDI_RENDER_SET_GAIN, HdiServiceRenderSetGain},
2215 {AUDIO_HDI_RENDER_GET_LATENCY, HdiServiceRenderGetLatency},
2216 {AUDIO_HDI_RENDER_RENDER_FRAME, HdiServiceRenderRenderFrame},
2217 {AUDIO_HDI_RENDER_GET_RENDER_POSITION, HdiServiceRenderGetRenderPosition},
2218 {AUDIO_HDI_RENDER_GET_SPEED, HdiServiceRenderGetSpeed},
2219 {AUDIO_HDI_RENDER_SET_SPEED, HdiServiceRenderSetSpeed},
2220 {AUDIO_HDI_RENDER_SET_CHANNEL_MODE, HdiServiceRenderSetChannelMode},
2221 {AUDIO_HDI_RENDER_GET_CHANNEL_MODE, HdiServiceRenderGetChannelMode},
2222 {AUDIO_HDI_RENDER_SET_EXTRA_PARAMS, HdiServiceRenderSetExtraParams},
2223 {AUDIO_HDI_RENDER_GET_EXTRA_PARAMS, HdiServiceRenderGetExtraParams},
2224 {AUDIO_HDI_RENDER_REQ_MMAP_BUFFER, HdiServiceRenderReqMmapBuffer},
2225 {AUDIO_HDI_RENDER_GET_MMAP_POSITION, HdiServiceRenderGetMmapPosition},
2226 {AUDIO_HDI_RENDER_ADD_EFFECT, HdiServiceRenderAddEffect},
2227 {AUDIO_HDI_RENDER_REMOVE_EFFECT, HdiServiceRenderRemoveEffect},
2228 {AUDIO_HDI_RENDER_TURN_STAND_BY_MODE, HdiServiceRenderTurnStandbyMode},
2229 {AUDIO_HDI_RENDER_DEV_DUMP, HdiServiceRenderDevDump},
2230 {AUDIO_HDI_RENDER_REG_CALLBACK, HdiServiceRenderRegCallback},
2231 {AUDIO_HDI_RENDER_DRAIN_BUFFER, HdiServiceRenderDrainBuffer},
2232 };
2233
2234 static struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleCapList[] = {
2235 {AUDIO_HDI_CAPTURE_CREATE_CAPTURE, HdiServiceCreatCapture},
2236 {AUDIO_HDI_CAPTURE_DESTROY, HdiServiceCaptureDestory},
2237 {AUDIO_HDI_CAPTURE_START, HdiServiceCaptureStart},
2238 {AUDIO_HDI_CAPTURE_STOP, HdiServiceCaptureStop},
2239 {AUDIO_HDI_CAPTURE_PAUSE, HdiServiceCapturePause},
2240 {AUDIO_HDI_CAPTURE_RESUME, HdiServiceCaptureResume},
2241 {AUDIO_HDI_CAPTURE_FLUSH, HdiServiceCaptureFlush},
2242 {AUDIO_HDI_CAPTURE_GET_FRAME_SIZE, HdiServiceCaptureGetFrameSize},
2243 {AUDIO_HDI_CAPTURE_GET_FRAME_COUNT, HdiServiceCaptureGetFrameCount},
2244 {AUDIO_HDI_CAPTURE_SET_SAMPLE_ATTR, HdiServiceCaptureSetSampleAttr},
2245 {AUDIO_HDI_CAPTURE_GET_SAMPLE_ATTR, HdiServiceCaptureGetSampleAttr},
2246 {AUDIO_HDI_CAPTURE_GET_CUR_CHANNEL_ID, HdiServiceCaptureGetCurChannelId},
2247 {AUDIO_HDI_CAPTURE_CHECK_SCENE_CAPABILITY, HdiServiceCaptureCheckSceneCapability},
2248 {AUDIO_HDI_CAPTURE_SELECT_SCENE, HdiServiceCaptureSelectScene},
2249 {AUDIO_HDI_CAPTURE_GET_MUTE, HdiServiceCaptureGetMute},
2250 {AUDIO_HDI_CAPTURE_SET_MUTE, HdiServiceCaptureSetMute},
2251 {AUDIO_HDI_CAPTURE_SET_VOLUME, HdiServiceCaptureSetVolume},
2252 {AUDIO_HDI_CAPTURE_GET_VOLUME, HdiServiceCaptureGetVolume},
2253 {AUDIO_HDI_CAPTURE_GET_GAIN_THRESHOLD, HdiServiceCaptureGetGainThreshold},
2254 {AUDIO_HDI_CAPTURE_GET_GAIN, HdiServiceCaptureGetGain},
2255 {AUDIO_HDI_CAPTURE_SET_GAIN, HdiServiceCaptureSetGain},
2256 {AUDIO_HDI_CAPTURE_CAPTURE_FRAME, HdiServiceCaptureCaptureFrame},
2257 {AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION, HdiServiceCaptureGetCapturePosition},
2258 {AUDIO_HDI_CAPTURE_SET_EXTRA_PARAMS, HdiServiceCaptureSetExtraParams},
2259 {AUDIO_HDI_CAPTURE_GET_EXTRA_PARAMS, HdiServiceCaptureGetExtraParams},
2260 {AUDIO_HDI_CAPTURE_REQ_MMAP_BUFFER, HdiServiceCaptureReqMmapBuffer},
2261 {AUDIO_HDI_CAPTURE_GET_MMAP_POSITION, HdiServiceCaptureGetMmapPosition},
2262 {AUDIO_HDI_CAPTURE_ADD_EFFECT, HdiServiceCaptureAddEffect},
2263 {AUDIO_HDI_CAPTURE_REMOVE_EFFECT, HdiServiceCaptureRemoveEffect},
2264 {AUDIO_HDI_CAPTURE_TURN_STAND_BY_MODE, HdiServiceCaptureTurnStandbyMode},
2265 {AUDIO_HDI_CAPTURE_DEV_DUMP, HdiServiceCaptureDevDump},
2266 };
2267
HdiServiceDispatch(struct HdfDeviceIoClient * client,int cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)2268 int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data,
2269 struct HdfSBuf *reply)
2270 {
2271 unsigned int i;
2272 AUDIO_FUNC_LOGD("cmdId = %{public}d", cmdId);
2273 if (client == NULL) {
2274 AUDIO_FUNC_LOGE("ControlDispatch: input para is NULL.");
2275 return AUDIO_HAL_ERR_INVALID_PARAM;
2276 }
2277
2278 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
2279 AUDIO_FUNC_LOGE("check interface token failed");
2280 return AUDIO_HAL_ERR_INVALID_PARAM;
2281 }
2282 if (cmdId > AUDIO_HDI_CAPTURE_DEV_DUMP || cmdId < 0) {
2283 AUDIO_FUNC_LOGE("ControlDispatch: invalid cmdId = %{public}d", cmdId);
2284 return AUDIO_HAL_ERR_INTERNAL;
2285 } else if (cmdId <= AUDIO_HDI_RENDER_DRAIN_BUFFER) {
2286 for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleList) /
2287 sizeof(g_hdiServiceDispatchCmdHandleList[0]); ++i) {
2288 if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleList[i].cmd)) &&
2289 (g_hdiServiceDispatchCmdHandleList[i].func != NULL)) {
2290 return g_hdiServiceDispatchCmdHandleList[i].func(client, data, reply);
2291 }
2292 }
2293 } else {
2294 for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleCapList) /
2295 sizeof(g_hdiServiceDispatchCmdHandleCapList[0]); ++i) {
2296 if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleCapList[i].cmd)) &&
2297 (g_hdiServiceDispatchCmdHandleCapList[i].func != NULL)) {
2298 return g_hdiServiceDispatchCmdHandleCapList[i].func(client, data, reply);
2299 }
2300 }
2301 }
2302 return AUDIO_HAL_ERR_INTERNAL;
2303 }
2304