1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Defines audio ADM test-related APIs, including data types and functions for writing data
21 to buffer.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_adm_common.h
29 *
30 * @brief Declares APIs for operations related to the audio ADM testing.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_adm_common.h"
37
38 using namespace std;
39
40 namespace OHOS {
41 namespace Audio {
WriteHwParamsToBuf(struct HdfSBuf * sBuf,struct AudioPcmHwParams hwParams)42 int32_t WriteHwParamsToBuf(struct HdfSBuf *sBuf, struct AudioPcmHwParams hwParams)
43 {
44 if (sBuf == nullptr) {
45 return HDF_FAILURE;
46 }
47 if (!HdfSbufWriteUint32(sBuf, (uint32_t)hwParams.streamType)) {
48 return HDF_FAILURE;
49 }
50 if (!HdfSbufWriteUint32(sBuf, hwParams.channels)) {
51 return HDF_FAILURE;
52 }
53 if (!HdfSbufWriteUint32(sBuf, hwParams.rate)) {
54 return HDF_FAILURE;
55 }
56 if (!HdfSbufWriteUint32(sBuf, hwParams.periodSize)) {
57 return HDF_FAILURE;
58 }
59 if (!HdfSbufWriteUint32(sBuf, hwParams.periodCount)) {
60 return HDF_FAILURE;
61 }
62 if (!HdfSbufWriteUint32(sBuf, (uint32_t)(hwParams.format))) {
63 return HDF_FAILURE;
64 }
65 if (!HdfSbufWriteString(sBuf, hwParams.cardServiceName)) {
66 return HDF_FAILURE;
67 }
68 if (!HdfSbufWriteUint32(sBuf, hwParams.period)) {
69 return HDF_FAILURE;
70 }
71 if (!HdfSbufWriteUint32(sBuf, hwParams.frameSize)) {
72 return HDF_FAILURE;
73 }
74 if (!HdfSbufWriteUint32(sBuf, (uint32_t)(hwParams.isBigEndian))) {
75 return HDF_FAILURE;
76 }
77 if (!HdfSbufWriteUint32(sBuf, (uint32_t)(hwParams.isSignedData))) {
78 return HDF_FAILURE;
79 }
80 if (!HdfSbufWriteUint32(sBuf, hwParams.startThreshold)) {
81 return HDF_FAILURE;
82 }
83 if (!HdfSbufWriteUint32(sBuf, hwParams.stopThreshold)) {
84 return HDF_FAILURE;
85 }
86 if (!HdfSbufWriteUint32(sBuf, hwParams.silenceThreshold)) {
87 return HDF_FAILURE;
88 }
89 return HDF_SUCCESS;
90 }
91
AdmRenderFramePrepare(const std::string & path,char * & frame,uint32_t & readSize,uint32_t & frameSize)92 int32_t AdmRenderFramePrepare(const std::string& path, char *&frame, uint32_t& readSize, uint32_t& frameSize)
93 {
94 int32_t ret = -1;
95 size_t numRead = 0;
96 uint32_t bufferSize = 0;
97
98 struct AudioSampleAttributes attrs = {};
99 InitAttrs(attrs);
100 char absPath[PATH_MAX] = {0};
101 if (realpath(path.c_str(), absPath) == nullptr) {
102 return HDF_FAILURE;
103 }
104 FILE *file = fopen(absPath, "rb");
105 if (file == nullptr) {
106 return HDF_FAILURE;
107 }
108 struct AudioHeadInfo headInfo = {};
109 ret = WavHeadAnalysis(headInfo, file, attrs);
110 if (ret < 0) {
111 fclose(file);
112 return HDF_FAILURE;
113 }
114 bufferSize = PcmFramesToBytes(attrs);
115 if (bufferSize == 0) {
116 fclose(file);
117 return HDF_FAILURE;
118 }
119 frame = reinterpret_cast<char *>(calloc(1, bufferSize));
120 if (frame == nullptr) {
121 fclose(file);
122 return HDF_FAILURE;
123 }
124 uint32_t remainingDataSize = 0;
125 remainingDataSize = headInfo.dataSize;
126 readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize);
127 numRead = fread(frame, readSize, 1, file);
128 if (numRead < 1) {
129 fclose(file);
130 free(frame);
131 frame = nullptr;
132 return HDF_FAILURE;
133 }
134 frameSize = readSize / (attrs.channelCount * (PcmFormatToBits(attrs.format) >> MOVE_RIGHT_NUM));
135 (void)fclose(file);
136 return HDF_SUCCESS;
137 }
138
WriteFrameToSBuf(struct HdfSBuf * & sBufT,const std::string & path)139 int32_t WriteFrameToSBuf(struct HdfSBuf *&sBufT, const std::string& path)
140 {
141 int32_t ret = -1;
142 sBufT = HdfSbufObtainDefaultSize();
143 char *buf = nullptr;
144 uint32_t bufsize = 0;
145 uint32_t frameSize = 0;
146 if (sBufT == NULL) {
147 return HDF_FAILURE;
148 }
149
150 ret = AdmRenderFramePrepare(path, buf, bufsize, frameSize);
151 if (ret < 0) {
152 return HDF_FAILURE;
153 }
154
155 if (!HdfSbufWriteUint32(sBufT, frameSize)) {
156 free(buf);
157 buf = nullptr;
158 return HDF_FAILURE;
159 }
160 if (!HdfSbufWriteBuffer(sBufT, buf, bufsize)) {
161 free(buf);
162 buf = nullptr;
163 return HDF_FAILURE;
164 }
165 free(buf);
166 buf = nullptr;
167 return HDF_SUCCESS;
168 }
169
WriteToSBuf(struct HdfSBuf * & sBufT)170 int32_t WriteToSBuf(struct HdfSBuf *&sBufT)
171 {
172 sBufT = HdfSbufObtainDefaultSize();
173 if (sBufT == NULL) {
174 return HDF_FAILURE;
175 }
176
177 if (!HdfSbufWriteUint32(sBufT, 0)) {
178 HdfSbufRecycle(sBufT);
179 sBufT = nullptr;
180 return HDF_FAILURE;
181 }
182 return HDF_SUCCESS;
183 }
184
ObtainBuf(struct HdfSBuf * & readBuf,struct HdfSBuf * & readReply)185 int32_t ObtainBuf(struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply)
186 {
187 readBuf = HdfSbufObtainDefaultSize();
188 if (readBuf == nullptr) {
189 return HDF_FAILURE;
190 }
191 readReply = HdfSbufObtainDefaultSize();
192 if (readReply == nullptr) {
193 HdfSbufRecycle(readBuf);
194 return HDF_FAILURE;
195 }
196 return HDF_SUCCESS;
197 }
198
RecycleBuf(struct HdfSBuf * & readBuf,struct HdfSBuf * & readReply)199 void RecycleBuf(struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply)
200 {
201 HdfSbufRecycle(readBuf);
202 HdfSbufRecycle(readReply);
203 }
204
WriteCtrlInfo(struct HdfIoService * service,struct AudioCtlElemValue writeElemValue)205 int32_t WriteCtrlInfo(struct HdfIoService *service, struct AudioCtlElemValue writeElemValue)
206 {
207 int32_t ret = -1;
208 struct HdfSBuf *writeBuf = nullptr;
209 if (service == nullptr || service->dispatcher == nullptr) {
210 return HDF_FAILURE;
211 }
212
213 writeBuf = HdfSbufObtainDefaultSize();
214 if (writeBuf == nullptr) {
215 return HDF_FAILURE;
216 }
217 ret = WriteEleValueToBuf(writeBuf, writeElemValue);
218 if (ret < 0) {
219 HdfSbufRecycle(writeBuf);
220 return HDF_FAILURE;
221 }
222 ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTRL_IOCTRL_ELEM_WRITE, writeBuf, nullptr);
223 if (ret < 0) {
224 HdfSbufRecycle(writeBuf);
225 return HDF_FAILURE;
226 }
227 HdfSbufRecycle(writeBuf);
228 return HDF_SUCCESS;
229 }
230
ReadCtrlInfo(struct HdfIoService * service,struct AudioCtlElemId id,int32_t expectValue)231 int32_t ReadCtrlInfo(struct HdfIoService *service, struct AudioCtlElemId id, int32_t expectValue)
232 {
233 int32_t ret = -1;
234 struct HdfSBuf *readBuf = nullptr;
235 struct HdfSBuf *readReply = nullptr;
236 struct AudioCtlElemValue readElemValue = {};
237 if (service == nullptr || service->dispatcher == nullptr) {
238 return HDF_FAILURE;
239 }
240 ret = ObtainBuf(readBuf, readReply);
241 if (ret < 0) {
242 return HDF_FAILURE;
243 }
244 ret = WriteIdToBuf(readBuf, id);
245 if (ret < 0) {
246 RecycleBuf(readBuf, readReply);
247 return HDF_FAILURE;
248 }
249 ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTRL_IOCTRL_ELEM_READ, readBuf, readReply);
250 if (ret < 0) {
251 RecycleBuf(readBuf, readReply);
252 return HDF_FAILURE;
253 }
254 ret = HdfSbufReadInt32(readReply, &readElemValue.value[0]);
255 if (ret < 0 || expectValue != readElemValue.value[0]) {
256 RecycleBuf(readBuf, readReply);
257 return HDF_FAILURE;
258 }
259 RecycleBuf(readBuf, readReply);
260 return HDF_SUCCESS;
261 }
WriteHwParams(const string serviceName,struct HdfIoService * & service,struct AudioPcmHwParams hwParams)262 int32_t WriteHwParams(const string serviceName, struct HdfIoService *&service, struct AudioPcmHwParams hwParams)
263 {
264 int32_t ret = -1;
265 int32_t cmdid = -1;
266 struct HdfSBuf *writeBuf = nullptr;
267 struct HdfSBuf *writeReply = nullptr;
268 if (!strcmp(serviceName.c_str(), HDF_CAPTURE_SERVICE.c_str())) {
269 cmdid = AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN;
270 } else {
271 cmdid = AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN;
272 }
273 service = HdfIoServiceBind(serviceName.c_str());
274 if (service == nullptr || service->dispatcher == nullptr) {
275 return HDF_FAILURE;
276 }
277 writeBuf = HdfSbufObtainDefaultSize();
278 if (writeBuf == nullptr) {
279 HdfIoServiceRecycle(service);
280 service = nullptr;
281 return HDF_FAILURE;
282 }
283
284 if (!HdfSbufWriteString(writeBuf, CARD_SEVICE_NAME.c_str())) {
285 HdfIoServiceRecycle(service);
286 return HDF_FAILURE;
287 }
288 ret = service->dispatcher->Dispatch(&service->object, cmdid, writeBuf, writeReply);
289 if (ret < 0) {
290 HdfSbufRecycle(writeBuf);
291 HdfIoServiceRecycle(service);
292 service = nullptr;
293 return HDF_FAILURE;
294 }
295 HdfSbufFlush(writeBuf);
296 ret = WriteHwParamsToBuf(writeBuf, hwParams);
297 if (ret < 0) {
298 HdfSbufRecycle(writeBuf);
299 HdfIoServiceRecycle(service);
300 service = nullptr;
301 return HDF_FAILURE;
302 }
303 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply);
304 if (ret < 0) {
305 HdfSbufRecycle(writeBuf);
306 HdfIoServiceRecycle(service);
307 service = nullptr;
308 return HDF_FAILURE;
309 }
310 HdfSbufRecycle(writeBuf);
311 return HDF_SUCCESS;
312 }
313 }
314 }
315