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