1 /*
2 * Copyright (c) 2025 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 <gtest/gtest.h>
17
18 #include "audio_errors.h"
19 #include "format_converter.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace AudioStandard {
25 namespace {
26 const size_t BUFFER_LENGTH_FOUR = 4;
27 const size_t BUFFER_LENGTH_EIGHT = 8;
28 }
29 class FormatConverterUnitTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 };
36
SetUpTestCase(void)37 void FormatConverterUnitTest::SetUpTestCase(void)
38 {
39 }
40
TearDownTestCase(void)41 void FormatConverterUnitTest::TearDownTestCase(void)
42 {
43 }
44
SetUp(void)45 void FormatConverterUnitTest::SetUp(void)
46 {
47 }
48
TearDown(void)49 void FormatConverterUnitTest::TearDown(void)
50 {
51 }
52
53 /**
54 * @tc.name : Test FormatConverter API
55 * @tc.type : FUNC
56 * @tc.number: S16StereoToF32Stereo_001
57 * @tc.desc : Test FormatConverter interface.
58 */
59 HWTEST_F(FormatConverterUnitTest, S16StereoToF32Stereo_001, TestSize.Level1)
60 {
61 BufferDesc srcDesc;
62 BufferDesc dstDesc;
63 int32_t ret = -1;
64 uint8_t srcBuffer[4] = {0};
65 uint8_t dstBuffer[8] = {0};
66
67 srcDesc.bufLength = 4;
68 srcDesc.buffer = srcBuffer;
69 dstDesc.bufLength = 2;
70 dstDesc.buffer = dstBuffer;
71
72 ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
73 EXPECT_EQ(ret, -1);
74
75 dstDesc.bufLength = 8;
76
77 ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
78 EXPECT_EQ(ret, 0);
79 }
80
81 /**
82 * @tc.name : Test FormatConverter API
83 * @tc.type : FUNC
84 * @tc.number: S16StereoToF32Mono_001
85 * @tc.desc : Test FormatConverter interface.
86 */
87 HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_001, TestSize.Level1)
88 {
89 BufferDesc srcDesc;
90 BufferDesc dstDesc;
91 int32_t ret = -1;
92 uint8_t srcBuffer[4] = {0};
93 uint8_t dstBuffer[4] = {0};
94
95 srcDesc.bufLength = 4;
96 srcDesc.buffer = srcBuffer;
97 dstDesc.bufLength = 2;
98 dstDesc.buffer = dstBuffer;
99
100 ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc);
101 EXPECT_EQ(ret, -1);
102
103 dstDesc.bufLength = 4;
104
105 ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc);
106 EXPECT_EQ(ret, 0);
107 }
108
109 /**
110 * @tc.name : Test FormatConverter API
111 * @tc.type : FUNC
112 * @tc.number: F32MonoToS16Stereo_001
113 * @tc.desc : Test FormatConverter interface.
114 */
115 HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_001, TestSize.Level1)
116 {
117 BufferDesc srcDesc;
118 BufferDesc dstDesc;
119 int32_t ret = -1;
120 uint8_t srcBuffer[4] = {0};
121 uint8_t dstBuffer[4] = {0};
122
123 srcDesc.bufLength = 4;
124 srcDesc.buffer = srcBuffer;
125 dstDesc.bufLength = 2;
126 dstDesc.buffer = dstBuffer;
127
128 ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc);
129 EXPECT_EQ(ret, -1);
130
131 dstDesc.bufLength = 4;
132
133 ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc);
134 EXPECT_EQ(ret, 0);
135 }
136
137 /**
138 * @tc.name : Test FormatConverter API
139 * @tc.type : FUNC
140 * @tc.number: F32StereoToS16Stereo_001
141 * @tc.desc : Test FormatConverter interface.
142 */
143 HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_001, TestSize.Level1)
144 {
145 BufferDesc srcDesc;
146 BufferDesc dstDesc;
147 int32_t ret = -1;
148 uint8_t srcBuffer[8] = {0};
149 uint8_t dstBuffer[4] = {0};
150
151 srcDesc.bufLength = 8;
152 srcDesc.buffer = srcBuffer;
153 dstDesc.bufLength = 2;
154 dstDesc.buffer = dstBuffer;
155
156 ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc);
157 EXPECT_EQ(ret, -1);
158
159 dstDesc.bufLength = 4;
160
161 ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc);
162 EXPECT_EQ(ret, 0);
163 }
164
165 /**
166 * @tc.name : Test FormatConverter API
167 * @tc.type : FUNC
168 * @tc.number: S16MonoToS16Stereo_001
169 * @tc.desc : Test FormatConverter interface.
170 */
171 HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_001, TestSize.Level1)
172 {
173 BufferDesc srcDesc;
174 BufferDesc dstDesc;
175 int32_t ret = -1;
176 uint8_t srcBuffer[8] = {0};
177 uint8_t dstBuffer[8] = {0};
178
179 srcDesc.bufLength = 2;
180 srcDesc.buffer = srcBuffer;
181 dstDesc.bufLength = 8;
182 dstDesc.buffer = dstBuffer;
183
184 ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc);
185 EXPECT_EQ(ret, -1);
186
187 ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc);
188 EXPECT_EQ(ret, -1);
189
190 ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc);
191 EXPECT_EQ(ret, -1);
192
193 ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc);
194 EXPECT_EQ(ret, -1);
195
196 ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc);
197 EXPECT_EQ(ret, -1);
198
199 ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc);
200 EXPECT_EQ(ret, -1);
201
202 ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc);
203 EXPECT_EQ(ret, -1);
204
205 ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
206 EXPECT_EQ(ret, -1);
207
208 ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc);
209 EXPECT_EQ(ret, -1);
210
211 ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc);
212 EXPECT_EQ(ret, -1);
213
214 ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc);
215 EXPECT_EQ(ret, -1);
216 }
217
218 /**
219 * @tc.name : Test FormatConverter API
220 * @tc.type : FUNC
221 * @tc.number: S16MonoToS16Stereo_002
222 * @tc.desc : Test FormatConverter interface.
223 */
224 HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_002, TestSize.Level1)
225 {
226 BufferDesc srcDesc;
227 BufferDesc dstDesc;
228 int32_t ret = -1;
229 uint8_t dstBuffer[8] = {0};
230
231 srcDesc.bufLength = 2;
232 srcDesc.buffer = nullptr;
233 dstDesc.bufLength = 8;
234 dstDesc.buffer = dstBuffer;
235
236 ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc);
237 EXPECT_EQ(ret, -1);
238
239 ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc);
240 EXPECT_EQ(ret, -1);
241
242 ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc);
243 EXPECT_EQ(ret, -1);
244
245 ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc);
246 EXPECT_EQ(ret, -1);
247
248 ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc);
249 EXPECT_EQ(ret, -1);
250
251 ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc);
252 EXPECT_EQ(ret, -1);
253
254 ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc);
255 EXPECT_EQ(ret, -1);
256
257 ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc);
258 EXPECT_EQ(ret, -1);
259
260 ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
261 EXPECT_EQ(ret, -1);
262
263 ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc);
264 EXPECT_EQ(ret, -1);
265
266 ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc);
267 EXPECT_EQ(ret, -1);
268 }
269
270 /**
271 * @tc.name : Test FormatConverter API
272 * @tc.type : FUNC
273 * @tc.number: S16MonoToS16Stereo_003
274 * @tc.desc : Test FormatConverter interface.
275 */
276 HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_003, TestSize.Level1)
277 {
278 BufferDesc srcDesc;
279 BufferDesc dstDesc;
280 int32_t ret = -1;
281 uint8_t srcBuffer[8] = {0};
282
283 srcDesc.bufLength = 2;
284 srcDesc.buffer = srcBuffer;
285 dstDesc.bufLength = 8;
286 dstDesc.buffer = nullptr;
287
288 ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc);
289 EXPECT_EQ(ret, -1);
290
291 ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc);
292 EXPECT_EQ(ret, -1);
293
294 ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc);
295 EXPECT_EQ(ret, -1);
296
297 ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc);
298 EXPECT_EQ(ret, -1);
299
300 ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc);
301 EXPECT_EQ(ret, -1);
302
303 ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc);
304 EXPECT_EQ(ret, -1);
305
306 ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc);
307 EXPECT_EQ(ret, -1);
308
309 ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc);
310 EXPECT_EQ(ret, -1);
311
312 ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
313 EXPECT_EQ(ret, -1);
314
315 ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc);
316 EXPECT_EQ(ret, -1);
317
318 ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc);
319 EXPECT_EQ(ret, -1);
320 }
321
322 /**
323 * @tc.name : Test FormatConverter API
324 * @tc.type : FUNC
325 * @tc.number: DataAccumulationFromVolume_001
326 * @tc.desc : Test FormatConverter interface: format not equal
327 */
328 HWTEST_F(FormatConverterUnitTest, DataAccumulationFromVolume_001, TestSize.Level0)
329 {
330 uint8_t srcBuffer[BUFFER_LENGTH_EIGHT] = {0};
331 BufferDesc srcDesc = {srcBuffer, BUFFER_LENGTH_EIGHT, BUFFER_LENGTH_EIGHT};
332 AudioStreamData srcData;
333 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
334 srcData.bufferDesc = srcDesc;
335 std::vector<AudioStreamData> srcDataList = {srcData};
336
337 uint8_t dstBuffer[BUFFER_LENGTH_FOUR] = {0};
338 BufferDesc dstDesc = {dstBuffer, BUFFER_LENGTH_FOUR, BUFFER_LENGTH_FOUR};
339 AudioStreamData dstData;
340 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
341 dstData.bufferDesc = dstDesc;
342
343 bool ret = FormatConverter::DataAccumulationFromVolume(srcDataList, dstData);
344
345 EXPECT_EQ(ret, false);
346 }
347
348 /**
349 * @tc.name : Test FormatConverter API
350 * @tc.type : FUNC
351 * @tc.number: DataAccumulationFromVolume_002
352 * @tc.desc : Test FormatConverter interface: mix s32
353 */
354 HWTEST_F(FormatConverterUnitTest, DataAccumulationFromVolume_002, TestSize.Level0)
355 {
356 uint8_t srcBuffer[BUFFER_LENGTH_EIGHT] = {0};
357 BufferDesc srcDesc = {srcBuffer, BUFFER_LENGTH_EIGHT, BUFFER_LENGTH_EIGHT};
358 AudioStreamData srcData;
359 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
360 srcData.bufferDesc = srcDesc;
361 std::vector<AudioStreamData> srcDataList = {srcData};
362
363 uint8_t dstBuffer[BUFFER_LENGTH_EIGHT] = {0};
364 BufferDesc dstDesc = {dstBuffer, BUFFER_LENGTH_EIGHT, BUFFER_LENGTH_EIGHT};
365 AudioStreamData dstData;
366 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO};
367 dstData.bufferDesc = dstDesc;
368
369 bool ret = FormatConverter::DataAccumulationFromVolume(srcDataList, dstData);
370
371 EXPECT_EQ(ret, true);
372 }
373
374 /**
375 * @tc.name : Test FormatConverter API
376 * @tc.type : FUNC
377 * @tc.number: DataAccumulationFromVolume_003
378 * @tc.desc : Test FormatConverter interface: mix s32
379 */
380 HWTEST_F(FormatConverterUnitTest, DataAccumulationFromVolume_003, TestSize.Level0)
381 {
382 uint8_t srcBuffer[BUFFER_LENGTH_FOUR] = {0};
383 BufferDesc srcDesc = {srcBuffer, BUFFER_LENGTH_FOUR, BUFFER_LENGTH_FOUR};
384 AudioStreamData srcData;
385 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
386 srcData.bufferDesc = srcDesc;
387 std::vector<AudioStreamData> srcDataList = {srcData};
388
389 uint8_t dstBuffer[BUFFER_LENGTH_FOUR] = {0};
390 BufferDesc dstDesc = {dstBuffer, BUFFER_LENGTH_FOUR, BUFFER_LENGTH_FOUR};
391 AudioStreamData dstData;
392 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
393 dstData.bufferDesc = dstDesc;
394
395 bool ret = FormatConverter::DataAccumulationFromVolume(srcDataList, dstData);
396
397 EXPECT_EQ(ret, true);
398 }
399
400 /**
401 * @tc.name : Test FormatConverter API
402 * @tc.type : FUNC
403 * @tc.number: DataAccumulationFromVolume_004
404 * @tc.desc : Test FormatConverter interface: not support f32
405 */
406 HWTEST_F(FormatConverterUnitTest, DataAccumulationFromVolume_004, TestSize.Level0)
407 {
408 uint8_t srcBuffer[BUFFER_LENGTH_EIGHT] = {0};
409 BufferDesc srcDesc = {srcBuffer, BUFFER_LENGTH_EIGHT, BUFFER_LENGTH_EIGHT};
410 AudioStreamData srcData;
411 srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_F32LE, STEREO};
412 srcData.bufferDesc = srcDesc;
413 std::vector<AudioStreamData> srcDataList = {srcData};
414
415 uint8_t dstBuffer[BUFFER_LENGTH_EIGHT] = {0};
416 BufferDesc dstDesc = {dstBuffer, BUFFER_LENGTH_EIGHT, BUFFER_LENGTH_EIGHT};
417 AudioStreamData dstData;
418 dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_F32LE, STEREO};
419 dstData.bufferDesc = dstDesc;
420
421 bool ret = FormatConverter::DataAccumulationFromVolume(srcDataList, dstData);
422
423 EXPECT_EQ(ret, false);
424 }
425 } // namespace OHOS::AudioStandard
426 } // namespace OHOS
427