1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <hdf_log.h>
16 #include "audio_internal.h"
17 #include "audio_adapter_info_common.h"
18 #include "audio_adapter.h"
19 #include "fast_audio_render.h"
20 namespace OHOS::HDI::Audio_Bluetooth {
21 constexpr int CONFIG_CHANNEL_COUNT = 2; // two channels
22 constexpr float GAIN_MAX = 50.0;
23
24 constexpr int DEFAULT_RENDER_SAMPLING_RATE = 48000;
25 constexpr int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096;
26 constexpr int DEEP_BUFFER_RENDER_PERIOD_COUNT = 8;
27 constexpr const char *TYPE_RENDER = "Render";
28 constexpr const char *TYPE_CAPTURE = "Capture";
29 constexpr const int SHIFT_RIGHT_31_BITS = 31;
30
GetFastRenderFuncs(struct AudioHwRender * hwRender)31 static void GetFastRenderFuncs(struct AudioHwRender *hwRender)
32 {
33 hwRender->common.control.Start = FastRenderStart;
34 hwRender->common.control.Stop = FastRenderStop;
35 hwRender->common.control.Pause = FastRenderPause;
36 hwRender->common.control.Resume = FastRenderResume;
37 hwRender->common.control.Flush = FastRenderFlush;
38 hwRender->common.control.TurnStandbyMode = FastRenderTurnStandbyMode;
39 hwRender->common.control.AudioDevDump = FastRenderAudioDevDump;
40 hwRender->common.attr.GetFrameSize = FastRenderGetFrameSize;
41 hwRender->common.attr.GetFrameCount = FastRenderGetFrameCount;
42 hwRender->common.attr.SetSampleAttributes = FastRenderSetSampleAttributes;
43 hwRender->common.attr.GetSampleAttributes = FastRenderGetSampleAttributes;
44 hwRender->common.attr.GetCurrentChannelId = FastRenderGetCurrentChannelId;
45 hwRender->common.attr.SetExtraParams = FastRenderSetExtraParams;
46 hwRender->common.attr.GetExtraParams = FastRenderGetExtraParams;
47 hwRender->common.attr.ReqMmapBuffer = FastRenderReqMmapBuffer;
48 hwRender->common.attr.GetMmapPosition = FastRenderGetMmapPosition;
49 hwRender->common.scene.CheckSceneCapability = FastRenderCheckSceneCapability;
50 hwRender->common.scene.SelectScene = FastRenderSelectScene;
51 hwRender->common.volume.SetMute = FastRenderSetMute;
52 hwRender->common.volume.GetMute = FastRenderGetMute;
53 hwRender->common.volume.SetVolume = FastRenderSetVolume;
54 hwRender->common.volume.GetVolume = FastRenderGetVolume;
55 hwRender->common.volume.GetGainThreshold = FastRenderGetGainThreshold;
56 hwRender->common.volume.GetGain = FastRenderGetGain;
57 hwRender->common.volume.SetGain = FastRenderSetGain;
58 hwRender->common.GetLatency = FastRenderGetLatency;
59 hwRender->common.RenderFrame = FastRenderRenderFrame;
60 hwRender->common.GetRenderPosition = FastRenderGetRenderPosition;
61 hwRender->common.SetRenderSpeed = FastRenderSetRenderSpeed;
62 hwRender->common.GetRenderSpeed = FastRenderGetRenderSpeed;
63 hwRender->common.SetChannelMode = FastRenderSetChannelMode;
64 hwRender->common.GetChannelMode = FastRenderGetChannelMode;
65 hwRender->common.RegCallback = FastRenderRegCallback;
66 hwRender->common.DrainBuffer = FastRenderDrainBuffer;
67 }
68
GetNormalRenderFuncs(struct AudioHwRender * hwRender)69 static void GetNormalRenderFuncs(struct AudioHwRender *hwRender)
70 {
71 hwRender->common.control.Start = AudioRenderStart;
72 hwRender->common.control.Stop = AudioRenderStop;
73 hwRender->common.control.Pause = AudioRenderPause;
74 hwRender->common.control.Resume = AudioRenderResume;
75 hwRender->common.control.Flush = AudioRenderFlush;
76 hwRender->common.control.TurnStandbyMode = AudioRenderTurnStandbyMode;
77 hwRender->common.control.AudioDevDump = AudioRenderAudioDevDump;
78 hwRender->common.attr.GetFrameSize = AudioRenderGetFrameSize;
79 hwRender->common.attr.GetFrameCount = AudioRenderGetFrameCount;
80 hwRender->common.attr.SetSampleAttributes = AudioRenderSetSampleAttributes;
81 hwRender->common.attr.GetSampleAttributes = AudioRenderGetSampleAttributes;
82 hwRender->common.attr.GetCurrentChannelId = AudioRenderGetCurrentChannelId;
83 hwRender->common.attr.SetExtraParams = AudioRenderSetExtraParams;
84 hwRender->common.attr.GetExtraParams = AudioRenderGetExtraParams;
85 hwRender->common.attr.ReqMmapBuffer = AudioRenderReqMmapBuffer;
86 hwRender->common.attr.GetMmapPosition = AudioRenderGetMmapPosition;
87 hwRender->common.scene.CheckSceneCapability = AudioRenderCheckSceneCapability;
88 hwRender->common.scene.SelectScene = AudioRenderSelectScene;
89 hwRender->common.volume.SetMute = AudioRenderSetMute;
90 hwRender->common.volume.GetMute = AudioRenderGetMute;
91 hwRender->common.volume.SetVolume = AudioRenderSetVolume;
92 hwRender->common.volume.GetVolume = AudioRenderGetVolume;
93 hwRender->common.volume.GetGainThreshold = AudioRenderGetGainThreshold;
94 hwRender->common.volume.GetGain = AudioRenderGetGain;
95 hwRender->common.volume.SetGain = AudioRenderSetGain;
96 hwRender->common.GetLatency = AudioRenderGetLatency;
97 hwRender->common.RenderFrame = AudioRenderRenderFrame;
98 hwRender->common.GetRenderPosition = AudioRenderGetRenderPosition;
99 hwRender->common.SetRenderSpeed = AudioRenderSetRenderSpeed;
100 hwRender->common.GetRenderSpeed = AudioRenderGetRenderSpeed;
101 hwRender->common.SetChannelMode = AudioRenderSetChannelMode;
102 hwRender->common.GetChannelMode = AudioRenderGetChannelMode;
103 hwRender->common.RegCallback = AudioRenderRegCallback;
104 hwRender->common.DrainBuffer = AudioRenderDrainBuffer;
105 }
106
GetCaptureFuncs(struct AudioHwCapture * hwCapture)107 static void GetCaptureFuncs(struct AudioHwCapture *hwCapture)
108 {
109 hwCapture->common.control.Start = AudioCaptureStart;
110 hwCapture->common.control.Stop = AudioCaptureStop;
111 hwCapture->common.control.Pause = AudioCapturePause;
112 hwCapture->common.control.Resume = AudioCaptureResume;
113 hwCapture->common.control.Flush = AudioCaptureFlush;
114 hwCapture->common.volume.SetMute = AudioCaptureSetMute;
115 hwCapture->common.volume.GetMute = AudioCaptureGetMute;
116 hwCapture->common.CaptureFrame = AudioCaptureCaptureFrame;
117 }
118
GetAudioRenderFunc(struct AudioHwRender * hwRender,const char * adapterName)119 int32_t GetAudioRenderFunc(struct AudioHwRender *hwRender, const char *adapterName)
120 {
121 if (hwRender == nullptr || adapterName == nullptr) {
122 return HDF_FAILURE;
123 }
124 if (strcmp(adapterName, "bt_a2dp_fast") == 0) {
125 GetFastRenderFuncs(hwRender);
126 } else {
127 GetNormalRenderFuncs(hwRender);
128 }
129 return HDF_SUCCESS;
130 }
131
GetAudioCaptureFunc(struct AudioHwCapture * hwCapture,const char * adapterName)132 int32_t GetAudioCaptureFunc(struct AudioHwCapture *hwCapture, const char *adapterName)
133 {
134 if (hwCapture == nullptr || adapterName == nullptr) {
135 return HDF_FAILURE;
136 }
137 GetCaptureFuncs(hwCapture);
138 return HDF_SUCCESS;
139 }
140
CheckParaDesc(const struct AudioDeviceDescriptor * desc,const char * type)141 int32_t CheckParaDesc(const struct AudioDeviceDescriptor *desc, const char *type)
142 {
143 if (desc == NULL || type == NULL) {
144 return HDF_FAILURE;
145 }
146 if ((desc->portId) >> SHIFT_RIGHT_31_BITS) {
147 return HDF_ERR_NOT_SUPPORT;
148 }
149 AudioPortPin pins = desc->pins;
150 if (!strcmp(type, TYPE_CAPTURE)) {
151 if (pins == PIN_IN_MIC || pins == PIN_IN_HS_MIC || pins == PIN_IN_LINEIN) {
152 return HDF_SUCCESS;
153 } else {
154 return HDF_ERR_NOT_SUPPORT;
155 }
156 } else if (!strcmp(type, TYPE_RENDER)) {
157 if (pins == PIN_OUT_SPEAKER || pins == PIN_OUT_HEADSET || pins == PIN_OUT_LINEOUT || pins == PIN_OUT_HDMI) {
158 return HDF_SUCCESS;
159 } else {
160 return HDF_ERR_NOT_SUPPORT;
161 }
162 }
163 return HDF_ERR_NOT_SUPPORT;
164 }
165
CheckParaAttr(const struct AudioSampleAttributes * attrs)166 int32_t CheckParaAttr(const struct AudioSampleAttributes *attrs)
167 {
168 if (attrs == NULL) {
169 return HDF_FAILURE;
170 }
171 int32_t ret = ((attrs->sampleRate) >> SHIFT_RIGHT_31_BITS) + ((attrs->channelCount) >> SHIFT_RIGHT_31_BITS) +
172 ((attrs->period) >> SHIFT_RIGHT_31_BITS) + ((attrs->frameSize) >> SHIFT_RIGHT_31_BITS) +
173 ((attrs->startThreshold) >> SHIFT_RIGHT_31_BITS) + ((attrs->stopThreshold) >> SHIFT_RIGHT_31_BITS) +
174 ((attrs->silenceThreshold) >> SHIFT_RIGHT_31_BITS);
175 if (ret > 0) {
176 return HDF_ERR_NOT_SUPPORT;
177 }
178 AudioCategory audioCategory = attrs->type;
179 if (audioCategory < AUDIO_IN_MEDIA || audioCategory > AUDIO_MMAP_NOIRQ) {
180 return HDF_ERR_NOT_SUPPORT;
181 }
182 AudioFormat audioFormat = attrs->format;
183 return CheckAttrFormat(audioFormat);
184 }
185
AttrFormatToBit(const struct AudioSampleAttributes * attrs,int32_t * format)186 int32_t AttrFormatToBit(const struct AudioSampleAttributes *attrs, int32_t *format)
187 {
188 if (attrs == NULL || format == NULL) {
189 return HDF_FAILURE;
190 }
191 AudioFormat audioFormat = attrs->format;
192 switch (audioFormat) {
193 case AUDIO_FORMAT_TYPE_PCM_8_BIT:
194 *format = BIT_NUM_8;
195 return HDF_SUCCESS;
196 case AUDIO_FORMAT_TYPE_PCM_16_BIT:
197 *format = BIT_NUM_16;
198 return HDF_SUCCESS;
199 case AUDIO_FORMAT_TYPE_PCM_24_BIT:
200 *format = BIT_NUM_24;
201 return HDF_SUCCESS;
202 case AUDIO_FORMAT_TYPE_PCM_32_BIT:
203 *format = BIT_NUM_32;
204 return HDF_SUCCESS;
205 default:
206 return HDF_ERR_NOT_SUPPORT;
207 }
208 }
209
InitHwRenderParam(struct AudioHwRender * hwRender,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs)210 int32_t InitHwRenderParam(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc,
211 const struct AudioSampleAttributes *attrs)
212 {
213 if (hwRender == NULL || desc == NULL || attrs == NULL) {
214 HDF_LOGE("InitHwRenderParam param Is NULL");
215 return HDF_FAILURE;
216 }
217 int32_t ret = CheckParaDesc(desc, TYPE_RENDER);
218 if (ret != HDF_SUCCESS) {
219 HDF_LOGE("CheckParaDesc Fail");
220 return ret;
221 }
222 ret = CheckParaAttr(attrs);
223 if (ret != HDF_SUCCESS) {
224 HDF_LOGE("CheckParaAttr Fail");
225 return ret;
226 }
227 int32_t formatValue = -1;
228 ret = AttrFormatToBit(attrs, &formatValue);
229 if (ret != HDF_SUCCESS) {
230 HDF_LOGE("AttrFormatToBit Fail");
231 return ret;
232 }
233 if (attrs->channelCount == 0) {
234 return HDF_FAILURE;
235 }
236 hwRender->renderParam.renderMode.hwInfo.deviceDescript = *desc;
237 hwRender->renderParam.frameRenderMode.attrs = *attrs;
238 hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax = GAIN_MAX; // init gainMax
239 hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin = 0;
240 hwRender->renderParam.frameRenderMode.frames = 0;
241 hwRender->renderParam.frameRenderMode.time.tvNSec = 0;
242 hwRender->renderParam.frameRenderMode.time.tvSec = 0;
243 hwRender->renderParam.frameRenderMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE;
244 hwRender->renderParam.frameRenderMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE;
245 hwRender->renderParam.frameRenderMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT;
246 hwRender->renderParam.frameRenderMode.attrs.period = attrs->period;
247 hwRender->renderParam.frameRenderMode.attrs.frameSize = attrs->frameSize;
248 hwRender->renderParam.frameRenderMode.attrs.startThreshold = attrs->startThreshold;
249 hwRender->renderParam.frameRenderMode.attrs.stopThreshold = attrs->stopThreshold;
250 hwRender->renderParam.frameRenderMode.attrs.silenceThreshold = attrs->silenceThreshold;
251 hwRender->renderParam.frameRenderMode.attrs.isBigEndian = attrs->isBigEndian;
252 hwRender->renderParam.frameRenderMode.attrs.isSignedData = attrs->isSignedData;
253 return HDF_SUCCESS;
254 }
255
InitHwCaptureParam(struct AudioHwCapture * hwCapture,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs)256 int32_t InitHwCaptureParam(struct AudioHwCapture *hwCapture, const struct AudioDeviceDescriptor *desc,
257 const struct AudioSampleAttributes *attrs)
258 {
259 if (hwCapture == nullptr || desc == nullptr || attrs == nullptr) {
260 HDF_LOGE("InitHwCaptureParam param Is NULL");
261 return HDF_FAILURE;
262 }
263 int32_t ret = CheckParaDesc(desc, TYPE_CAPTURE);
264 if (ret != HDF_SUCCESS) {
265 HDF_LOGE("CheckParaDesc Fail");
266 return ret;
267 }
268 ret = CheckParaAttr(attrs);
269 if (ret != HDF_SUCCESS) {
270 HDF_LOGE("CheckParaAttr Fail");
271 return ret;
272 }
273 int32_t formatValue = -1;
274 ret = AttrFormatToBit(attrs, &formatValue);
275 if (ret != HDF_SUCCESS) {
276 HDF_LOGE("AttrFormatToBit Fail");
277 return ret;
278 }
279 if (attrs->channelCount == 0) {
280 return HDF_FAILURE;
281 }
282 hwCapture->captureParam.captureMode.hwInfo.deviceDescript = *desc;
283 hwCapture->captureParam.frameCaptureMode.attrs = *attrs;
284 hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax = GAIN_MAX; // init gainMax
285 hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin = 0;
286 hwCapture->captureParam.frameCaptureMode.frames = 0;
287 hwCapture->captureParam.frameCaptureMode.time.tvNSec = 0;
288 hwCapture->captureParam.frameCaptureMode.time.tvSec = 0;
289 hwCapture->captureParam.frameCaptureMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE;
290 hwCapture->captureParam.frameCaptureMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE;
291 hwCapture->captureParam.frameCaptureMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT;
292 hwCapture->captureParam.frameCaptureMode.attrs.period = attrs->period;
293 hwCapture->captureParam.frameCaptureMode.attrs.frameSize = attrs->frameSize;
294 hwCapture->captureParam.frameCaptureMode.attrs.startThreshold = attrs->startThreshold;
295 hwCapture->captureParam.frameCaptureMode.attrs.stopThreshold = attrs->stopThreshold;
296 hwCapture->captureParam.frameCaptureMode.attrs.silenceThreshold = attrs->silenceThreshold;
297 hwCapture->captureParam.frameCaptureMode.attrs.isBigEndian = attrs->isBigEndian;
298 hwCapture->captureParam.frameCaptureMode.attrs.isSignedData = attrs->isSignedData;
299 return HDF_SUCCESS;
300 }
301
302 AudioFormat g_formatIdZero = AUDIO_FORMAT_TYPE_PCM_16_BIT;
InitForGetPortCapability(struct AudioPort portIndex,struct AudioPortCapability * capabilityIndex)303 int32_t InitForGetPortCapability(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex)
304 {
305 if (capabilityIndex == NULL) {
306 HDF_LOGE("capabilityIndex Is NULL");
307 return HDF_FAILURE;
308 }
309 /* get capabilityIndex from driver or default */
310 if (portIndex.dir != PORT_OUT) {
311 capabilityIndex->hardwareMode = true;
312 capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
313 capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
314 return HDF_SUCCESS;
315 }
316 if (portIndex.portId == 0) {
317 capabilityIndex->hardwareMode = true;
318 capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
319 capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
320 capabilityIndex->deviceType = portIndex.dir;
321 capabilityIndex->deviceId = PIN_OUT_SPEAKER;
322 capabilityIndex->formatNum = 1;
323 capabilityIndex->formats = &g_formatIdZero;
324 capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000;
325 capabilityIndex->subPortsNum = 1;
326 capabilityIndex->subPorts =
327 reinterpret_cast<struct AudioSubPortCapability *>(calloc(capabilityIndex->subPortsNum,
328 sizeof(struct AudioSubPortCapability)));
329 if (capabilityIndex->subPorts == NULL) {
330 HDF_LOGE("capabilityIndex subPorts is NULL!");
331 return HDF_FAILURE;
332 }
333 capabilityIndex->subPorts->portId = portIndex.portId;
334 capabilityIndex->subPorts->desc = portIndex.portName;
335 capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM;
336 return HDF_SUCCESS;
337 }
338 if (portIndex.portId == 1) {
339 capabilityIndex->hardwareMode = true;
340 capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
341 capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
342 capabilityIndex->deviceType = portIndex.dir;
343 capabilityIndex->deviceId = PIN_OUT_HEADSET;
344 capabilityIndex->formatNum = 1;
345 capabilityIndex->formats = &g_formatIdZero;
346 capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_8000;
347 return HDF_SUCCESS;
348 }
349 if (portIndex.portId == HDMI_PORT_ID) {
350 return HdmiPortInit(portIndex, capabilityIndex);
351 }
352 return HDF_FAILURE;
353 }
354
AudioAdapterReleaseCapSubPorts(const struct AudioPortAndCapability * portCapabilitys,int32_t num)355 void AudioAdapterReleaseCapSubPorts(const struct AudioPortAndCapability *portCapabilitys, int32_t num)
356 {
357 int32_t i = 0;
358 if (portCapabilitys == NULL) {
359 return;
360 }
361 while (i < num) {
362 if (&portCapabilitys[i] == NULL) {
363 break;
364 }
365 AudioMemFree((void **)(&portCapabilitys[i].capability.subPorts));
366 i++;
367 }
368 return;
369 }
370
AudioAdapterInitAllPorts(struct AudioAdapter * adapter)371 int32_t AudioAdapterInitAllPorts(struct AudioAdapter *adapter)
372 {
373 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
374 if (hwAdapter == NULL) {
375 HDF_LOGE("hwAdapter Is NULL");
376 return AUDIO_HAL_ERR_INVALID_PARAM;
377 }
378 if (hwAdapter->portCapabilitys != NULL) {
379 HDF_LOGE("portCapabilitys already Init!");
380 return AUDIO_HAL_SUCCESS;
381 }
382 uint32_t portNum = hwAdapter->adapterDescriptor.portNum;
383 struct AudioPort *ports = hwAdapter->adapterDescriptor.ports;
384 if (ports == NULL) {
385 HDF_LOGE("ports is NULL!");
386 return AUDIO_HAL_ERR_INTERNAL;
387 }
388 if (portNum == 0) {
389 return AUDIO_HAL_ERR_INTERNAL;
390 }
391 struct AudioPortAndCapability *portCapability =
392 reinterpret_cast<struct AudioPortAndCapability *>(calloc(portNum, sizeof(struct AudioPortAndCapability)));
393 if (portCapability == NULL) {
394 HDF_LOGE("portCapability is NULL!");
395 return AUDIO_HAL_ERR_INTERNAL;
396 }
397 for (uint32_t i = 0; i < portNum; i++) {
398 portCapability[i].port = ports[i];
399 if (InitForGetPortCapability(ports[i], &portCapability[i].capability)) {
400 HDF_LOGE("ports Init Fail!");
401 AudioAdapterReleaseCapSubPorts(portCapability, portNum);
402 AudioMemFree((void **)&portCapability);
403 return AUDIO_HAL_ERR_INTERNAL;
404 }
405 }
406 hwAdapter->portCapabilitys = portCapability;
407 hwAdapter->portCapabilitys->mode = PORT_PASSTHROUGH_LPCM;
408 return AUDIO_HAL_SUCCESS;
409 }
410
AudioReleaseRenderHandle(struct AudioHwRender * hwRender)411 void AudioReleaseRenderHandle(struct AudioHwRender *hwRender)
412 {
413 return;
414 }
415
AudioReleaseCaptureHandle(struct AudioHwCapture * hwCapture)416 void AudioReleaseCaptureHandle(struct AudioHwCapture *hwCapture)
417 {
418 return;
419 }
420
AudioAdapterCreateRenderPre(struct AudioHwRender * hwRender,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,const struct AudioHwAdapter * hwAdapter)421 int32_t AudioAdapterCreateRenderPre(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc,
422 const struct AudioSampleAttributes *attrs, const struct AudioHwAdapter *hwAdapter)
423 {
424 HDF_LOGD("%s", __func__);
425 if (hwAdapter == NULL || hwRender == NULL || desc == NULL || attrs == NULL) {
426 HDF_LOGE("Pointer is null!");
427 return HDF_FAILURE;
428 }
429
430 /* Fill hwRender para */
431 if (InitHwRenderParam(hwRender, desc, attrs) < 0) {
432 return HDF_FAILURE;
433 }
434
435 if (GetAudioRenderFunc(hwRender, hwAdapter->adapterDescriptor.adapterName) < 0) {
436 return HDF_FAILURE;
437 }
438 /* Select Path */
439 if (hwAdapter->adapterDescriptor.adapterName == NULL) {
440 HDF_LOGE("pointer is null!");
441 return HDF_FAILURE;
442 }
443 uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName);
444 if (adapterNameLen == 0) {
445 HDF_LOGE("adapterNameLen is null!");
446 return HDF_FAILURE;
447 }
448 /* Get Adapter name */
449 int32_t ret = strncpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, NAME_LEN - 1,
450 hwAdapter->adapterDescriptor.adapterName, adapterNameLen);
451 if (ret != EOK) {
452 HDF_LOGE("copy fail");
453 return HDF_FAILURE;
454 }
455 return HDF_SUCCESS;
456 }
457
AudioAdapterCreateCapturePre(struct AudioHwCapture * hwCapture,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,const struct AudioHwAdapter * hwAdapter)458 int32_t AudioAdapterCreateCapturePre(struct AudioHwCapture *hwCapture, const struct AudioDeviceDescriptor *desc,
459 const struct AudioSampleAttributes *attrs, const struct AudioHwAdapter *hwAdapter)
460 {
461 HDF_LOGD("%s", __func__);
462 if (hwAdapter == nullptr || hwCapture == nullptr || desc == nullptr || attrs == nullptr) {
463 HDF_LOGE("Pointer is null!");
464 return HDF_FAILURE;
465 }
466 if (InitHwCaptureParam(hwCapture, desc, attrs) < 0) {
467 return HDF_FAILURE;
468 }
469 if (GetAudioCaptureFunc(hwCapture, hwAdapter->adapterDescriptor.adapterName) < 0) {
470 return HDF_FAILURE;
471 }
472 if (hwAdapter->adapterDescriptor.adapterName == nullptr) {
473 HDF_LOGE("pointer is null!");
474 return HDF_FAILURE;
475 }
476 uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName);
477 if (adapterNameLen == 0) {
478 HDF_LOGE("adapterNameLen is null!");
479 return HDF_FAILURE;
480 }
481 int32_t ret = strncpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN - 1,
482 hwAdapter->adapterDescriptor.adapterName, adapterNameLen);
483 if (ret != EOK) {
484 HDF_LOGE("copy fail");
485 return HDF_FAILURE;
486 }
487 return HDF_SUCCESS;
488 }
489
AudioAdapterCreateRender(struct AudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct AudioRender ** render)490 int32_t AudioAdapterCreateRender(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
491 const struct AudioSampleAttributes *attrs, struct AudioRender **render)
492 {
493 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
494 if (hwAdapter == NULL || desc == NULL || attrs == NULL || render == NULL) {
495 return AUDIO_HAL_ERR_INVALID_PARAM;
496 }
497 if (hwAdapter->adapterMgrRenderFlag > 0) {
498 HDF_LOGE("Create render repeatedly!");
499 return AUDIO_HAL_ERR_INTERNAL;
500 }
501 struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(calloc(1, sizeof(*hwRender)));
502 if (hwRender == NULL) {
503 HDF_LOGE("hwRender is NULL!");
504 return AUDIO_HAL_ERR_MALLOC_FAIL;
505 }
506 int32_t ret = AudioAdapterCreateRenderPre(hwRender, desc, attrs, hwAdapter);
507 if (ret != 0) {
508 HDF_LOGE("AudioAdapterCreateRenderPre fail");
509 AudioMemFree(reinterpret_cast<void **>(&hwRender));
510 return AUDIO_HAL_ERR_INTERNAL;
511 }
512 hwAdapter->adapterMgrRenderFlag++;
513 *render = &hwRender->common;
514 return AUDIO_HAL_SUCCESS;
515 }
516
AudioAdapterCreateCapture(struct AudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct AudioCapture ** capture)517 int32_t AudioAdapterCreateCapture(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
518 const struct AudioSampleAttributes *attrs, struct AudioCapture **capture)
519 {
520 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
521 if (hwAdapter == nullptr || desc == nullptr || attrs == nullptr || capture == nullptr) {
522 return AUDIO_HAL_ERR_INVALID_PARAM;
523 }
524 if (hwAdapter->adapterMgrCaptureFlag > 0) {
525 HDF_LOGE("Create capture repeatedly!");
526 return AUDIO_HAL_ERR_INTERNAL;
527 }
528 struct AudioHwCapture *hwCapture = reinterpret_cast<struct AudioHwCapture *>(calloc(1, sizeof(*hwCapture)));
529 if (hwCapture == nullptr) {
530 HDF_LOGE("hwCapture is NULL!");
531 return AUDIO_HAL_ERR_MALLOC_FAIL;
532 }
533 int32_t ret = AudioAdapterCreateCapturePre(hwCapture, desc, attrs, hwAdapter);
534 if (ret != 0) {
535 HDF_LOGE("AudioAdapterCreateCapturePre fail");
536 AudioMemFree(reinterpret_cast<void **>(&hwCapture));
537 return AUDIO_HAL_ERR_INTERNAL;
538 }
539 hwAdapter->adapterMgrCaptureFlag++;
540 *capture = &hwCapture->common;
541 return AUDIO_HAL_SUCCESS;
542 }
543
AudioAdapterDestroyRender(struct AudioAdapter * adapter,struct AudioRender * render)544 int32_t AudioAdapterDestroyRender(struct AudioAdapter *adapter, struct AudioRender *render)
545 {
546 HDF_LOGI("enter");
547 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
548 if (hwAdapter == NULL || render == NULL) {
549 return AUDIO_HAL_ERR_INVALID_PARAM;
550 }
551 if (hwAdapter->adapterMgrRenderFlag > 0) {
552 hwAdapter->adapterMgrRenderFlag--;
553 }
554 struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(render);
555 if (hwRender == NULL) {
556 return AUDIO_HAL_ERR_INTERNAL;
557 }
558 if (hwRender->renderParam.frameRenderMode.buffer != NULL) {
559 HDF_LOGI("render not stop, first stop it.");
560 int ret = render->control.Stop((AudioHandle)render);
561 if (ret < 0) {
562 HDF_LOGE("render Stop failed");
563 }
564 }
565 AudioReleaseRenderHandle(hwRender);
566 AudioMemFree(reinterpret_cast<void **>(&hwRender->renderParam.frameRenderMode.buffer));
567 AudioMemFree(reinterpret_cast<void **>(&render));
568 HDF_LOGI("AudioAdapterDestroyRender cleaned.");
569 return AUDIO_HAL_SUCCESS;
570 }
571
AudioAdapterDestroyCapture(struct AudioAdapter * adapter,struct AudioCapture * capture)572 int32_t AudioAdapterDestroyCapture(struct AudioAdapter *adapter, struct AudioCapture *capture)
573 {
574 HDF_LOGI("enter");
575 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
576 if (hwAdapter == nullptr || capture == nullptr) {
577 return AUDIO_HAL_ERR_INVALID_PARAM;
578 }
579 if (hwAdapter->adapterMgrCaptureFlag > 0) {
580 hwAdapter->adapterMgrCaptureFlag--;
581 }
582 struct AudioHwCapture *hwCapture = reinterpret_cast<struct AudioHwCapture *>(capture);
583 if (hwCapture == nullptr) {
584 return AUDIO_HAL_ERR_INTERNAL;
585 }
586 AudioReleaseCaptureHandle(hwCapture);
587 AudioMemFree(reinterpret_cast<void **>(&capture));
588 HDF_LOGI("AudioAdapterDestroyCapture cleaned.");
589 return AUDIO_HAL_SUCCESS;
590 }
591
AudioAdapterGetPortCapability(struct AudioAdapter * adapter,const struct AudioPort * port,struct AudioPortCapability * capability)592 int32_t AudioAdapterGetPortCapability(struct AudioAdapter *adapter, const struct AudioPort *port,
593 struct AudioPortCapability *capability)
594 {
595 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
596 if (hwAdapter == NULL || port == NULL || port->portName == NULL || capability == NULL) {
597 return AUDIO_HAL_ERR_INVALID_PARAM;
598 }
599 if (port->portId < 0) {
600 return AUDIO_HAL_ERR_INTERNAL;
601 }
602 struct AudioPortAndCapability *hwAdapterPortCapabilitys = hwAdapter->portCapabilitys;
603 if (hwAdapterPortCapabilitys == NULL) {
604 HDF_LOGE("hwAdapter portCapabilitys is NULL!");
605 return AUDIO_HAL_ERR_INTERNAL;
606 }
607 int32_t portNum = hwAdapter->adapterDescriptor.portNum;
608 while (hwAdapterPortCapabilitys != NULL && portNum) {
609 if (hwAdapterPortCapabilitys->port.portId == port->portId) {
610 *capability = hwAdapterPortCapabilitys->capability;
611 return AUDIO_HAL_SUCCESS;
612 }
613 hwAdapterPortCapabilitys++;
614 portNum--;
615 }
616 return AUDIO_HAL_ERR_INTERNAL;
617 }
618
AudioAdapterSetPassthroughMode(struct AudioAdapter * adapter,const struct AudioPort * port,AudioPortPassthroughMode mode)619 int32_t AudioAdapterSetPassthroughMode(struct AudioAdapter *adapter,
620 const struct AudioPort *port, AudioPortPassthroughMode mode)
621 {
622 if (adapter == NULL || port == NULL || port->portName == NULL) {
623 return AUDIO_HAL_ERR_INVALID_PARAM;
624 }
625 if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) {
626 return AUDIO_HAL_ERR_INTERNAL;
627 }
628 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
629 if (hwAdapter->portCapabilitys == NULL) {
630 HDF_LOGE("The pointer is null!");
631 return AUDIO_HAL_ERR_INTERNAL;
632 }
633 struct AudioPortAndCapability *portCapabilityTemp = hwAdapter->portCapabilitys;
634 struct AudioPortCapability *portCapability = NULL;
635 int32_t portNum = hwAdapter->adapterDescriptor.portNum;
636 while (portCapabilityTemp != NULL && portNum > 0) {
637 if (portCapabilityTemp->port.portId == port->portId) {
638 portCapability = &portCapabilityTemp->capability;
639 break;
640 }
641 portCapabilityTemp++;
642 portNum--;
643 }
644 if (portCapability == NULL || portNum <= 0) {
645 HDF_LOGE("hwAdapter portCapabilitys is Not Find!");
646 return AUDIO_HAL_ERR_INTERNAL;
647 }
648 struct AudioSubPortCapability *subPortCapability = portCapability->subPorts;
649 if (subPortCapability == NULL) {
650 HDF_LOGE("portCapability->subPorts is NULL!");
651 return AUDIO_HAL_ERR_INTERNAL;
652 }
653 int32_t subPortNum = portCapability->subPortsNum;
654 while (subPortCapability != NULL && subPortNum > 0) {
655 if (subPortCapability->mask == mode) {
656 portCapabilityTemp->mode = mode;
657 break;
658 }
659 subPortCapability++;
660 subPortNum--;
661 }
662 if (subPortNum > 0) {
663 return AUDIO_HAL_SUCCESS;
664 }
665 return AUDIO_HAL_ERR_INTERNAL;
666 }
667
AudioAdapterGetPassthroughMode(struct AudioAdapter * adapter,const struct AudioPort * port,AudioPortPassthroughMode * mode)668 int32_t AudioAdapterGetPassthroughMode(struct AudioAdapter *adapter, const struct AudioPort *port,
669 AudioPortPassthroughMode *mode)
670 {
671 if (adapter == NULL || port == NULL || port->portName == NULL || mode == NULL) {
672 return AUDIO_HAL_ERR_INVALID_PARAM;
673 }
674 if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) {
675 return AUDIO_HAL_ERR_INTERNAL;
676 }
677 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
678 if (hwAdapter->portCapabilitys == NULL) {
679 HDF_LOGE("portCapabilitys pointer is null!");
680 return AUDIO_HAL_ERR_INTERNAL;
681 }
682 struct AudioPortAndCapability *portCapabilitys = hwAdapter->portCapabilitys;
683 int32_t portNum = hwAdapter->adapterDescriptor.portNum;
684 while (portCapabilitys != NULL && portNum > 0) {
685 if (portCapabilitys->port.portId == port->portId) {
686 *mode = portCapabilitys->mode;
687 return AUDIO_HAL_SUCCESS;
688 }
689 portCapabilitys++;
690 portNum--;
691 }
692 return AUDIO_HAL_ERR_INTERNAL;
693 }
694
AudioAdapterSetExtraParams(struct AudioAdapter * adapter,enum AudioExtParamKey key,const char * condition,const char * value)695 int32_t AudioAdapterSetExtraParams(struct AudioAdapter *adapter, enum AudioExtParamKey key,
696 const char *condition, const char *value)
697 {
698 (void)adapter;
699 (void)key;
700 (void)condition;
701 (void)value;
702 return HDF_ERR_NOT_SUPPORT;
703 }
704
AudioAdapterGetExtraParams(struct AudioAdapter * adapter,enum AudioExtParamKey key,const char * condition,char * value,int32_t length)705 int32_t AudioAdapterGetExtraParams(struct AudioAdapter *adapter, enum AudioExtParamKey key,
706 const char *condition, char *value, int32_t length)
707 {
708 (void)adapter;
709 (void)key;
710 (void)condition;
711 (void)value;
712 (void)length;
713 return HDF_ERR_NOT_SUPPORT;
714 }
715
716 }