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 
GetAudioRenderFunc(struct AudioHwRender * hwRender,const char * adapterName)107 int32_t GetAudioRenderFunc(struct AudioHwRender *hwRender, const char *adapterName)
108 {
109     if (hwRender == nullptr || adapterName == nullptr) {
110         return HDF_FAILURE;
111     }
112     if (strcmp(adapterName, "bt_a2dp_fast") == 0) {
113         GetFastRenderFuncs(hwRender);
114     } else {
115         GetNormalRenderFuncs(hwRender);
116     }
117     return HDF_SUCCESS;
118 }
119 
CheckParaDesc(const struct AudioDeviceDescriptor * desc,const char * type)120 int32_t CheckParaDesc(const struct AudioDeviceDescriptor *desc, const char *type)
121 {
122     if (desc == NULL || type == NULL) {
123         return HDF_FAILURE;
124     }
125     if ((desc->portId) >> SHIFT_RIGHT_31_BITS) {
126         return HDF_ERR_NOT_SUPPORT;
127     }
128     AudioPortPin pins = desc->pins;
129     if (!strcmp(type, TYPE_CAPTURE)) {
130         if (pins == PIN_IN_MIC || pins == PIN_IN_HS_MIC || pins == PIN_IN_LINEIN) {
131             return HDF_SUCCESS;
132         } else {
133             return HDF_ERR_NOT_SUPPORT;
134         }
135     } else if (!strcmp(type, TYPE_RENDER)) {
136         if (pins == PIN_OUT_SPEAKER || pins == PIN_OUT_HEADSET || pins == PIN_OUT_LINEOUT || pins == PIN_OUT_HDMI) {
137             return HDF_SUCCESS;
138         } else {
139             return HDF_ERR_NOT_SUPPORT;
140         }
141     }
142     return HDF_ERR_NOT_SUPPORT;
143 }
144 
CheckParaAttr(const struct AudioSampleAttributes * attrs)145 int32_t CheckParaAttr(const struct AudioSampleAttributes *attrs)
146 {
147     if (attrs == NULL) {
148         return HDF_FAILURE;
149     }
150     int32_t ret = ((attrs->sampleRate) >> SHIFT_RIGHT_31_BITS) + ((attrs->channelCount) >> SHIFT_RIGHT_31_BITS) +
151         ((attrs->period) >> SHIFT_RIGHT_31_BITS) + ((attrs->frameSize) >> SHIFT_RIGHT_31_BITS) +
152         ((attrs->startThreshold) >> SHIFT_RIGHT_31_BITS) + ((attrs->stopThreshold) >> SHIFT_RIGHT_31_BITS) +
153         ((attrs->silenceThreshold) >> SHIFT_RIGHT_31_BITS);
154     if (ret > 0) {
155         return HDF_ERR_NOT_SUPPORT;
156     }
157     AudioCategory audioCategory = attrs->type;
158     if (audioCategory < AUDIO_IN_MEDIA || audioCategory > AUDIO_MMAP_NOIRQ) {
159         return HDF_ERR_NOT_SUPPORT;
160     }
161     AudioFormat audioFormat = attrs->format;
162     return CheckAttrFormat(audioFormat);
163 }
164 
AttrFormatToBit(const struct AudioSampleAttributes * attrs,int32_t * format)165 int32_t AttrFormatToBit(const struct AudioSampleAttributes *attrs, int32_t *format)
166 {
167     if (attrs == NULL || format == NULL) {
168         return HDF_FAILURE;
169     }
170     AudioFormat audioFormat = attrs->format;
171     switch (audioFormat) {
172         case AUDIO_FORMAT_TYPE_PCM_8_BIT:
173             *format = BIT_NUM_8;
174             return HDF_SUCCESS;
175         case AUDIO_FORMAT_TYPE_PCM_16_BIT:
176             *format = BIT_NUM_16;
177             return HDF_SUCCESS;
178         case AUDIO_FORMAT_TYPE_PCM_24_BIT:
179             *format = BIT_NUM_24;
180             return HDF_SUCCESS;
181         case AUDIO_FORMAT_TYPE_PCM_32_BIT:
182             *format = BIT_NUM_32;
183             return HDF_SUCCESS;
184         default:
185             return HDF_ERR_NOT_SUPPORT;
186     }
187 }
188 
InitHwRenderParam(struct AudioHwRender * hwRender,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs)189 int32_t InitHwRenderParam(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc,
190                           const struct AudioSampleAttributes *attrs)
191 {
192     if (hwRender == NULL || desc == NULL || attrs == NULL) {
193         HDF_LOGE("InitHwRenderParam param Is NULL");
194         return HDF_FAILURE;
195     }
196     int32_t ret = CheckParaDesc(desc, TYPE_RENDER);
197     if (ret != HDF_SUCCESS) {
198         HDF_LOGE("CheckParaDesc Fail");
199         return ret;
200     }
201     ret = CheckParaAttr(attrs);
202     if (ret != HDF_SUCCESS) {
203         HDF_LOGE("CheckParaAttr Fail");
204         return ret;
205     }
206     int32_t formatValue = -1;
207     ret = AttrFormatToBit(attrs, &formatValue);
208     if (ret != HDF_SUCCESS) {
209         HDF_LOGE("AttrFormatToBit Fail");
210         return ret;
211     }
212     if (attrs->channelCount == 0) {
213         return HDF_FAILURE;
214     }
215     hwRender->renderParam.renderMode.hwInfo.deviceDescript = *desc;
216     hwRender->renderParam.frameRenderMode.attrs = *attrs;
217     hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax = GAIN_MAX;  // init gainMax
218     hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin = 0;
219     hwRender->renderParam.frameRenderMode.frames = 0;
220     hwRender->renderParam.frameRenderMode.time.tvNSec = 0;
221     hwRender->renderParam.frameRenderMode.time.tvSec = 0;
222     hwRender->renderParam.frameRenderMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE;
223     hwRender->renderParam.frameRenderMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE;
224     hwRender->renderParam.frameRenderMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT;
225     hwRender->renderParam.frameRenderMode.attrs.period = attrs->period;
226     hwRender->renderParam.frameRenderMode.attrs.frameSize = attrs->frameSize;
227     hwRender->renderParam.frameRenderMode.attrs.startThreshold = attrs->startThreshold;
228     hwRender->renderParam.frameRenderMode.attrs.stopThreshold = attrs->stopThreshold;
229     hwRender->renderParam.frameRenderMode.attrs.silenceThreshold = attrs->silenceThreshold;
230     hwRender->renderParam.frameRenderMode.attrs.isBigEndian = attrs->isBigEndian;
231     hwRender->renderParam.frameRenderMode.attrs.isSignedData = attrs->isSignedData;
232     return HDF_SUCCESS;
233 }
234 
235 AudioFormat g_formatIdZero = AUDIO_FORMAT_TYPE_PCM_16_BIT;
InitForGetPortCapability(struct AudioPort portIndex,struct AudioPortCapability * capabilityIndex)236 int32_t InitForGetPortCapability(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex)
237 {
238     if (capabilityIndex == NULL) {
239         HDF_LOGE("capabilityIndex Is NULL");
240         return HDF_FAILURE;
241     }
242     /* get capabilityIndex from driver or default */
243     if (portIndex.dir != PORT_OUT) {
244         capabilityIndex->hardwareMode = true;
245         capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
246         capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
247         return HDF_SUCCESS;
248     }
249     if (portIndex.portId == 0) {
250         capabilityIndex->hardwareMode = true;
251         capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
252         capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
253         capabilityIndex->deviceType = portIndex.dir;
254         capabilityIndex->deviceId = PIN_OUT_SPEAKER;
255         capabilityIndex->formatNum = 1;
256         capabilityIndex->formats = &g_formatIdZero;
257         capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000;
258         capabilityIndex->subPortsNum = 1;
259         capabilityIndex->subPorts =
260             reinterpret_cast<struct AudioSubPortCapability *>(calloc(capabilityIndex->subPortsNum,
261             sizeof(struct AudioSubPortCapability)));
262         if (capabilityIndex->subPorts == NULL) {
263             HDF_LOGE("capabilityIndex subPorts is NULL!");
264             return HDF_FAILURE;
265         }
266         capabilityIndex->subPorts->portId = portIndex.portId;
267         capabilityIndex->subPorts->desc = portIndex.portName;
268         capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM;
269         return HDF_SUCCESS;
270     }
271     if (portIndex.portId == 1) {
272         capabilityIndex->hardwareMode = true;
273         capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
274         capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
275         capabilityIndex->deviceType = portIndex.dir;
276         capabilityIndex->deviceId = PIN_OUT_HEADSET;
277         capabilityIndex->formatNum = 1;
278         capabilityIndex->formats = &g_formatIdZero;
279         capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_8000;
280         return HDF_SUCCESS;
281     }
282     if (portIndex.portId == HDMI_PORT_ID) {
283         return HdmiPortInit(portIndex, capabilityIndex);
284     }
285     return HDF_FAILURE;
286 }
287 
AudioAdapterReleaseCapSubPorts(const struct AudioPortAndCapability * portCapabilitys,int32_t num)288 void AudioAdapterReleaseCapSubPorts(const struct AudioPortAndCapability *portCapabilitys, int32_t num)
289 {
290     int32_t i = 0;
291     if (portCapabilitys == NULL) {
292         return;
293     }
294     while (i < num) {
295         if (&portCapabilitys[i] == NULL) {
296             break;
297         }
298         AudioMemFree((void **)(&portCapabilitys[i].capability.subPorts));
299         i++;
300     }
301     return;
302 }
303 
AudioAdapterInitAllPorts(struct AudioAdapter * adapter)304 int32_t AudioAdapterInitAllPorts(struct AudioAdapter *adapter)
305 {
306     struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
307     if (hwAdapter == NULL) {
308         HDF_LOGE("hwAdapter Is NULL");
309         return AUDIO_HAL_ERR_INVALID_PARAM;
310     }
311     if (hwAdapter->portCapabilitys != NULL) {
312         HDF_LOGE("portCapabilitys already Init!");
313         return AUDIO_HAL_SUCCESS;
314     }
315     uint32_t portNum = hwAdapter->adapterDescriptor.portNum;
316     struct AudioPort *ports = hwAdapter->adapterDescriptor.ports;
317     if (ports == NULL) {
318         HDF_LOGE("ports is NULL!");
319         return AUDIO_HAL_ERR_INTERNAL;
320     }
321     if (portNum == 0) {
322         return AUDIO_HAL_ERR_INTERNAL;
323     }
324     struct AudioPortAndCapability *portCapability =
325         reinterpret_cast<struct AudioPortAndCapability *>(calloc(portNum, sizeof(struct AudioPortAndCapability)));
326     if (portCapability == NULL) {
327         HDF_LOGE("portCapability is NULL!");
328         return AUDIO_HAL_ERR_INTERNAL;
329     }
330     for (uint32_t i = 0; i < portNum; i++) {
331         portCapability[i].port = ports[i];
332         if (InitForGetPortCapability(ports[i], &portCapability[i].capability)) {
333             HDF_LOGE("ports Init Fail!");
334             AudioAdapterReleaseCapSubPorts(portCapability, portNum);
335             AudioMemFree((void **)&portCapability);
336             return AUDIO_HAL_ERR_INTERNAL;
337         }
338     }
339     hwAdapter->portCapabilitys = portCapability;
340     hwAdapter->portCapabilitys->mode = PORT_PASSTHROUGH_LPCM;
341     return AUDIO_HAL_SUCCESS;
342 }
343 
AudioReleaseRenderHandle(struct AudioHwRender * hwRender)344 void AudioReleaseRenderHandle(struct AudioHwRender *hwRender)
345 {
346     return;
347 }
348 
AudioAdapterCreateRenderPre(struct AudioHwRender * hwRender,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,const struct AudioHwAdapter * hwAdapter)349 int32_t AudioAdapterCreateRenderPre(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc,
350                                     const struct AudioSampleAttributes *attrs, const struct AudioHwAdapter *hwAdapter)
351 {
352     HDF_LOGD("%s", __func__);
353     if (hwAdapter == NULL || hwRender == NULL || desc == NULL || attrs == NULL) {
354         HDF_LOGE("Pointer is null!");
355         return HDF_FAILURE;
356     }
357 
358     /* Fill hwRender para */
359     if (InitHwRenderParam(hwRender, desc, attrs) < 0) {
360         return HDF_FAILURE;
361     }
362 
363     if (GetAudioRenderFunc(hwRender, hwAdapter->adapterDescriptor.adapterName) < 0) {
364         return HDF_FAILURE;
365     }
366     /* Select Path */
367     if (hwAdapter->adapterDescriptor.adapterName == NULL) {
368         HDF_LOGE("pointer is null!");
369         return HDF_FAILURE;
370     }
371     uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName);
372     if (adapterNameLen == 0) {
373         HDF_LOGE("adapterNameLen is null!");
374         return HDF_FAILURE;
375     }
376     /* Get Adapter name */
377     int32_t ret = strncpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, NAME_LEN - 1,
378                             hwAdapter->adapterDescriptor.adapterName, adapterNameLen);
379     if (ret != EOK) {
380         HDF_LOGE("copy fail");
381         return HDF_FAILURE;
382     }
383     return HDF_SUCCESS;
384 }
385 
AudioAdapterCreateRender(struct AudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct AudioRender ** render)386 int32_t AudioAdapterCreateRender(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
387                                  const struct AudioSampleAttributes *attrs, struct AudioRender **render)
388 {
389     struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
390     if (hwAdapter == NULL || desc == NULL || attrs == NULL || render == NULL) {
391         return AUDIO_HAL_ERR_INVALID_PARAM;
392     }
393     if (hwAdapter->adapterMgrRenderFlag > 0) {
394         HDF_LOGE("Create render repeatedly!");
395         return AUDIO_HAL_ERR_INTERNAL;
396     }
397     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(calloc(1, sizeof(*hwRender)));
398     if (hwRender == NULL) {
399         HDF_LOGE("hwRender is NULL!");
400         return AUDIO_HAL_ERR_MALLOC_FAIL;
401     }
402     int32_t ret = AudioAdapterCreateRenderPre(hwRender, desc, attrs, hwAdapter);
403     if (ret != 0) {
404         HDF_LOGE("AudioAdapterCreateRenderPre fail");
405         AudioMemFree(reinterpret_cast<void **>(&hwRender));
406         return AUDIO_HAL_ERR_INTERNAL;
407     }
408     hwAdapter->adapterMgrRenderFlag++;
409     *render = &hwRender->common;
410     return AUDIO_HAL_SUCCESS;
411 }
412 
AudioAdapterDestroyRender(struct AudioAdapter * adapter,struct AudioRender * render)413 int32_t AudioAdapterDestroyRender(struct AudioAdapter *adapter, struct AudioRender *render)
414 {
415     HDF_LOGI("enter");
416     struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
417     if (hwAdapter == NULL || render == NULL) {
418         return AUDIO_HAL_ERR_INVALID_PARAM;
419     }
420     if (hwAdapter->adapterMgrRenderFlag > 0) {
421         hwAdapter->adapterMgrRenderFlag--;
422     }
423     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(render);
424     if (hwRender == NULL) {
425         return AUDIO_HAL_ERR_INTERNAL;
426     }
427     if (hwRender->renderParam.frameRenderMode.buffer != NULL) {
428         HDF_LOGI("render not stop, first stop it.");
429         int ret = render->control.Stop((AudioHandle)render);
430         if (ret < 0) {
431             HDF_LOGE("render Stop failed");
432         }
433     }
434     AudioReleaseRenderHandle(hwRender);
435     AudioMemFree(reinterpret_cast<void **>(&hwRender->renderParam.frameRenderMode.buffer));
436     AudioMemFree(reinterpret_cast<void **>(&render));
437     HDF_LOGI("AudioAdapterDestroyRender cleaned.");
438     return AUDIO_HAL_SUCCESS;
439 }
440 
AudioAdapterGetPortCapability(struct AudioAdapter * adapter,const struct AudioPort * port,struct AudioPortCapability * capability)441 int32_t AudioAdapterGetPortCapability(struct AudioAdapter *adapter, const struct AudioPort *port,
442                                       struct AudioPortCapability *capability)
443 {
444     struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
445     if (hwAdapter == NULL || port == NULL || port->portName == NULL || capability == NULL) {
446         return AUDIO_HAL_ERR_INVALID_PARAM;
447     }
448     if (port->portId < 0) {
449         return AUDIO_HAL_ERR_INTERNAL;
450     }
451     struct AudioPortAndCapability *hwAdapterPortCapabilitys = hwAdapter->portCapabilitys;
452     if (hwAdapterPortCapabilitys == NULL) {
453         HDF_LOGE("hwAdapter portCapabilitys is NULL!");
454         return AUDIO_HAL_ERR_INTERNAL;
455     }
456     int32_t portNum = hwAdapter->adapterDescriptor.portNum;
457     while (hwAdapterPortCapabilitys != NULL && portNum) {
458         if (hwAdapterPortCapabilitys->port.portId == port->portId) {
459             *capability = hwAdapterPortCapabilitys->capability;
460             return AUDIO_HAL_SUCCESS;
461         }
462         hwAdapterPortCapabilitys++;
463         portNum--;
464     }
465     return AUDIO_HAL_ERR_INTERNAL;
466 }
467 
AudioAdapterSetPassthroughMode(struct AudioAdapter * adapter,const struct AudioPort * port,AudioPortPassthroughMode mode)468 int32_t AudioAdapterSetPassthroughMode(struct AudioAdapter *adapter,
469     const struct AudioPort *port, AudioPortPassthroughMode mode)
470 {
471     if (adapter == NULL || port == NULL || port->portName == NULL) {
472         return AUDIO_HAL_ERR_INVALID_PARAM;
473     }
474     if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) {
475         return AUDIO_HAL_ERR_INTERNAL;
476     }
477     struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
478     if (hwAdapter->portCapabilitys == NULL) {
479         HDF_LOGE("The pointer is null!");
480         return AUDIO_HAL_ERR_INTERNAL;
481     }
482     struct AudioPortAndCapability *portCapabilityTemp = hwAdapter->portCapabilitys;
483     struct AudioPortCapability *portCapability = NULL;
484     int32_t portNum = hwAdapter->adapterDescriptor.portNum;
485     while (portCapabilityTemp != NULL && portNum > 0) {
486         if (portCapabilityTemp->port.portId == port->portId) {
487             portCapability = &portCapabilityTemp->capability;
488             break;
489         }
490         portCapabilityTemp++;
491         portNum--;
492     }
493     if (portCapability == NULL || portNum <= 0) {
494         HDF_LOGE("hwAdapter portCapabilitys is Not Find!");
495         return AUDIO_HAL_ERR_INTERNAL;
496     }
497     struct AudioSubPortCapability *subPortCapability = portCapability->subPorts;
498     if (subPortCapability == NULL) {
499         HDF_LOGE("portCapability->subPorts is NULL!");
500         return AUDIO_HAL_ERR_INTERNAL;
501     }
502     int32_t subPortNum = portCapability->subPortsNum;
503     while (subPortCapability != NULL && subPortNum > 0) {
504         if (subPortCapability->mask == mode) {
505             portCapabilityTemp->mode = mode;
506             break;
507         }
508         subPortCapability++;
509         subPortNum--;
510     }
511     if (subPortNum > 0) {
512         return AUDIO_HAL_SUCCESS;
513     }
514     return AUDIO_HAL_ERR_INTERNAL;
515 }
516 
AudioAdapterGetPassthroughMode(struct AudioAdapter * adapter,const struct AudioPort * port,AudioPortPassthroughMode * mode)517 int32_t AudioAdapterGetPassthroughMode(struct AudioAdapter *adapter, const struct AudioPort *port,
518                                        AudioPortPassthroughMode *mode)
519 {
520     if (adapter == NULL || port == NULL || port->portName == NULL || mode == NULL) {
521         return AUDIO_HAL_ERR_INVALID_PARAM;
522     }
523     if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) {
524         return AUDIO_HAL_ERR_INTERNAL;
525     }
526     struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
527     if (hwAdapter->portCapabilitys == NULL) {
528         HDF_LOGE("portCapabilitys pointer is null!");
529         return AUDIO_HAL_ERR_INTERNAL;
530     }
531     struct AudioPortAndCapability *portCapabilitys = hwAdapter->portCapabilitys;
532     int32_t portNum = hwAdapter->adapterDescriptor.portNum;
533     while (portCapabilitys != NULL && portNum > 0) {
534         if (portCapabilitys->port.portId == port->portId) {
535             *mode = portCapabilitys->mode;
536             return AUDIO_HAL_SUCCESS;
537         }
538         portCapabilitys++;
539         portNum--;
540     }
541     return AUDIO_HAL_ERR_INTERNAL;
542 }
543 
AudioAdapterSetExtraParams(struct AudioAdapter * adapter,enum AudioExtParamKey key,const char * condition,const char * value)544 int32_t AudioAdapterSetExtraParams(struct AudioAdapter *adapter, enum AudioExtParamKey key,
545                                    const char *condition, const char *value)
546 {
547     (void)adapter;
548     (void)key;
549     (void)condition;
550     (void)value;
551     return HDF_ERR_NOT_SUPPORT;
552 }
553 
AudioAdapterGetExtraParams(struct AudioAdapter * adapter,enum AudioExtParamKey key,const char * condition,char * value,int32_t length)554 int32_t AudioAdapterGetExtraParams(struct AudioAdapter *adapter, enum AudioExtParamKey key,
555                                    const char *condition, char *value, int32_t length)
556 {
557     (void)adapter;
558     (void)key;
559     (void)condition;
560     (void)value;
561     (void)length;
562     return HDF_ERR_NOT_SUPPORT;
563 }
564 
565 }