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 <vector>
17 #include <queue>
18 #include <mutex>
19 #include <gtest/gtest.h>
20 #include <iostream>
21 #include <unistd.h>
22 #include <atomic>
23 #include <fstream>
24 #include <queue>
25 #include <string>
26 #include <thread>
27 #include "securec.h"
28 #include "avcodec_codec_name.h"
29 #include "avcodec_common.h"
30 #include "avcodec_errors.h"
31 #include "avcodec_mime_type.h"
32 #include "media_description.h"
33 #include "native_avcodec_base.h"
34 #include "native_avformat.h"
35 #include "avcodec_common.h"
36 #include "avcodec_errors.h"
37 #include "native_avcodec_audiocodec.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::MediaAVCodec;
42 using namespace OHOS::Media::Plugins;
43
44 namespace {
45 constexpr int32_t CHANNEL_COUNT = 2;
46 constexpr int32_t SAMPLE_RATE = 44100;
47 constexpr int64_t BIT_RATE = 128000;
48 constexpr uint32_t AAC_SAMPLE_PER_FRAME = 1024;
49 constexpr uint32_t G711MU_DEFAULT_FRAME_BYTES = 320; // 8kHz 20ms: 2*160
50 const string OPUS_SO_FILE_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_ext_base.z.so";
51 constexpr uint32_t OPUS_SAMPLE_RATE = 48000;
52 constexpr long OPUS_BITS_RATE = 15000;
53 constexpr int32_t OPUS_COMPLIANCE_LEVEL = 10;
54 constexpr int32_t OPUS_FRAME_SAMPLE_SIZES = 960 * 2 * 2;
55 constexpr uint32_t MAX_OUTPUT_TRY_CNT = 30;
56 constexpr string_view AAC_INPUT_FILE_PATH = "/data/test/media/aac_2c_44100hz_199k.pcm";
57 constexpr string_view AAC_OUTPUT_FILE_PATH = "/data/test/media/aac_2c_44100hz_encode.aac";
58 constexpr string_view FLAC_INPUT_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.pcm";
59 constexpr string_view FLAC_OUTPUT_FILE_PATH = "/data/test/media/encoderTest.flac";
60 constexpr string_view G711MU_INPUT_FILE_PATH = "/data/test/media/g711mu_8kHz_10s.pcm";
61 constexpr string_view G711MU_OUTPUT_FILE_PATH = "/data/test/media/g711mu_8kHz_10s_afterEncode.raw";
62 constexpr string_view OPUS_INPUT_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.pcm";
63 constexpr string_view OPUS_OUTPUT_FILE_PATH = "/data/test/media/encoderTest.opus";
64
65 // decoder test
66 constexpr string_view INPUT_AAC_FILE_PATH = "/data/test/media/aac_2c_44100hz_199k.dat";
67 constexpr string_view OUTPUT_AAC_PCM_FILE_PATH = "/data/test/media/aac_2c_44100hz_199k.pcm";
68 constexpr string_view INPUT_FLAC_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.dat";
69 constexpr string_view OUTPUT_FLAC_PCM_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.pcm";
70 constexpr string_view INPUT_MP3_FILE_PATH = "/data/test/media/mp3_2c_44100hz_60k.dat";
71 constexpr string_view OUTPUT_MP3_PCM_FILE_PATH = "/data/test/media/mp3_2c_44100hz_60k.pcm";
72 constexpr string_view INPUT_VORBIS_FILE_PATH = "/data/test/media/vorbis_2c_44100hz_320k.dat";
73 constexpr string_view OUTPUT_VORBIS_PCM_FILE_PATH = "/data/test/media/vorbis_2c_44100hz_320k.pcm";
74 constexpr string_view INPUT_AMRNB_FILE_PATH = "/data/test/media/voice_amrnb_12200.dat";
75 constexpr string_view OUTPUT_AMRNB_PCM_FILE_PATH = "/data/test/media/voice_amrnb_12200.pcm";
76 constexpr string_view INPUT_AMRWB_FILE_PATH = "/data/test/media/voice_amrwb_23850.dat";
77 constexpr string_view OUTPUT_AMRWB_PCM_FILE_PATH = "/data/test/media/voice_amrwb_23850.pcm";
78 constexpr string_view INPUT_G711MU_FILE_PATH = "/data/test/media/g711mu_8kHz.dat";
79 constexpr string_view OUTPUT_G711MU_PCM_FILE_PATH = "/data/test/media/g711mu_8kHz_decode.pcm";
80 constexpr string_view INPUT_OPUS_FILE_PATH = "/data/test/media/voice_opus.dat";
81 constexpr string_view OUTPUT_OPUS_PCM_FILE_PATH = "/data/test/media/opus_decode.pcm";
82 constexpr string_view INPUT_APE_FILE_PATH = "/data/test/media/voice_ape.dat";
83 constexpr string_view OUTPUT_APE_PCM_FILE_PATH = "/data/test/media/ape_decode.pcm";
84 constexpr string_view INPUT_AAC_LC_ADTS_FILE_PATH = "/data/test/media/aac_2c_44100hz_199k_lc.dat";
85 constexpr string_view OUTPUT_AAC_LC_ADTS_FILE_PATH = "/data/test/media/aac_2c_44100hz_199k_lc.pcm";
86 }
87
88 namespace OHOS {
89 namespace MediaAVCodec {
90
91 class AudioSyncModeCapiUnitTest : public testing::Test {
92 public:
93 static void SetUpTestCase(void);
94 static void TearDownTestCase(void);
95 void SetUp();
96 void TearDown();
97 bool CheckOpusSoFunc();
98 void EncoderRun();
99 void EncoderRunIndependentOutput();
100 bool DecoderFillInputBuffer(OH_AVBuffer *buffer);
101 void DecoderRun();
102 void DecoderRunIndependentOutput();
103 void OutputThread();
104 protected:
105 std::atomic<bool> isRunning_ = false;
106 std::unique_ptr<std::thread> outThread_;
107 OH_AVCodec *codec_ = nullptr;
108 OH_AVFormat *format_ = nullptr;
109 std::unique_ptr<std::ifstream> inputFile_;
110 std::unique_ptr<std::ofstream> outputFile_;
111 int32_t channels_ = CHANNEL_COUNT;
112 int32_t sampleRate_ = SAMPLE_RATE;
113 uint32_t inputFrameBytes_ = 8192;
114 uint32_t inputSizeCnt_ = 0;
115 uint32_t decodeInputFrameCnt_ = 0;
116 uint32_t outputFrameCnt_ = 0;
117 uint32_t outputFormatChangedTimes = 0;
118 int32_t outputSampleRate = 0;
119 int32_t outputChannels = 0;
120 int64_t inTimeout_ = 20000; // 20000us: 20ms
121 int64_t outTimeout_ = 20000; // 20000us: 20ms
122 };
123
SetUpTestCase(void)124 void AudioSyncModeCapiUnitTest::SetUpTestCase(void)
125 {
126 cout << "[SetUpTestCase]: " << endl;
127 }
128
TearDownTestCase(void)129 void AudioSyncModeCapiUnitTest::TearDownTestCase(void)
130 {
131 cout << "[TearDownTestCase]: " << endl;
132 }
133
SetUp(void)134 void AudioSyncModeCapiUnitTest::SetUp(void)
135 {
136 format_ = OH_AVFormat_Create();
137 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_ENABLE_SYNC_MODE, 1);
138 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, sampleRate_);
139 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_CHANNEL_COUNT, channels_);
140 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
141 OH_AVFormat_SetLongValue(format_, OH_MD_KEY_BITRATE, BIT_RATE);
142 inputSizeCnt_ = 0;
143 outputFrameCnt_ = 0;
144 }
145
TearDown(void)146 void AudioSyncModeCapiUnitTest::TearDown(void)
147 {
148 if (format_ != nullptr) {
149 OH_AVFormat_Destroy(format_);
150 format_ = nullptr;
151 }
152 if (inputFile_ != nullptr) {
153 if (inputFile_->is_open()) {
154 inputFile_->close();
155 }
156 }
157 if (outputFile_ != nullptr) {
158 if (outputFile_->is_open()) {
159 outputFile_->close();
160 }
161 }
162 }
163
CheckOpusSoFunc()164 bool AudioSyncModeCapiUnitTest::CheckOpusSoFunc()
165 {
166 std::unique_ptr<std::ifstream> soFile = std::make_unique<std::ifstream>(OPUS_SO_FILE_PATH, std::ios::binary);
167 if (!soFile->is_open()) {
168 cout << "Fatal: Open opus so file failed" << endl;
169 return false;
170 }
171 soFile->close();
172 return true;
173 }
174
EncoderRun()175 void AudioSyncModeCapiUnitTest::EncoderRun()
176 {
177 ASSERT_EQ(OH_AudioCodec_Prepare(codec_), AV_ERR_OK);
178 ASSERT_EQ(OH_AudioCodec_Start(codec_), AV_ERR_OK);
179 bool inputEnd = false;
180 OH_AVErrCode ret = AV_ERR_OK;
181 OH_AVCodecBufferAttr attr;
182 for (;;) {
183 uint32_t index = 0;
184 if (!inputEnd) {
185 ret = OH_AudioCodec_QueryInputBuffer(codec_, &index, inTimeout_);
186 if (ret == AV_ERR_TRY_AGAIN_LATER) {
187 continue;
188 }
189 ASSERT_EQ(ret, AV_ERR_OK);
190 OH_AVBuffer *inputBuf = OH_AudioCodec_GetInputBuffer(codec_, index);
191 ASSERT_NE(inputBuf, nullptr);
192 memset_s(&attr, sizeof(attr), 0, sizeof(attr));
193 if (!inputFile_->eof()) {
194 inputFile_->read((char *)OH_AVBuffer_GetAddr(inputBuf), inputFrameBytes_);
195 int32_t readSize = inputFile_->gcount();
196 attr.size = readSize;
197 attr.flags = readSize != 0 ? AVCODEC_BUFFER_FLAGS_NONE : AVCODEC_BUFFER_FLAGS_EOS;
198 inputSizeCnt_ += readSize;
199 } else {
200 inputEnd = true;
201 attr.size = 0;
202 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
203 cout << "input index:" << index << ", EOS" << endl;
204 }
205 EXPECT_EQ(OH_AVBuffer_SetBufferAttr(inputBuf, &attr), AV_ERR_OK);
206 EXPECT_EQ(OH_AudioCodec_PushInputBuffer(codec_, index), AV_ERR_OK);
207 }
208 ret = OH_AudioCodec_QueryOutputBuffer(codec_, &index, outTimeout_);
209 if (ret == AV_ERR_TRY_AGAIN_LATER) {
210 cout << "output index get timeout" << endl;
211 continue;
212 }
213 EXPECT_EQ(ret, AV_ERR_OK);
214 OH_AVBuffer *outputBuf = OH_AudioCodec_GetOutputBuffer(codec_, index);
215 ASSERT_NE(outputBuf, nullptr);
216 ASSERT_EQ(OH_AVBuffer_GetBufferAttr(outputBuf, &attr), AV_ERR_OK);
217 if (attr.flags & AVCODEC_BUFFER_FLAGS_EOS) {
218 cout << "output eos" << endl;
219 break;
220 }
221 outputFrameCnt_++;
222 outputFile_->write(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(outputBuf)), attr.size);
223 ASSERT_EQ(OH_AudioCodec_FreeOutputBuffer(codec_, index), AV_ERR_OK);
224 }
225 }
226
EncoderRunIndependentOutput()227 void AudioSyncModeCapiUnitTest::EncoderRunIndependentOutput()
228 {
229 ASSERT_EQ(OH_AudioCodec_Prepare(codec_), AV_ERR_OK);
230 ASSERT_EQ(OH_AudioCodec_Start(codec_), AV_ERR_OK);
231 isRunning_.store(true);
232 outThread_ = make_unique<thread>(&AudioSyncModeCapiUnitTest::OutputThread, this);
233 for (;;) {
234 uint32_t index = 0;
235 OH_AVErrCode ret = OH_AudioCodec_QueryInputBuffer(codec_, &index, inTimeout_);
236 if (ret == AV_ERR_TRY_AGAIN_LATER) {
237 continue;
238 }
239 ASSERT_EQ(ret, AV_ERR_OK);
240 OH_AVBuffer *inputBuf = OH_AudioCodec_GetInputBuffer(codec_, index);
241 ASSERT_NE(inputBuf, nullptr);
242 OH_AVCodecBufferAttr attr;
243 memset_s(&attr, sizeof(attr), 0, sizeof(attr));
244 if (!inputFile_->eof()) {
245 inputFile_->read((char *)OH_AVBuffer_GetAddr(inputBuf), inputFrameBytes_);
246 int32_t readSize = inputFile_->gcount();
247 attr.size = readSize;
248 attr.flags = readSize != 0 ? AVCODEC_BUFFER_FLAGS_NONE : AVCODEC_BUFFER_FLAGS_EOS;
249 inputSizeCnt_ += readSize;
250 cout << "input index:" << index << ", size:" << readSize << endl;
251 } else {
252 attr.size = 0;
253 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
254 cout << "input index:" << index << ", EOS" << endl;
255 }
256 EXPECT_EQ(OH_AVBuffer_SetBufferAttr(inputBuf, &attr), AV_ERR_OK);
257 EXPECT_EQ(OH_AudioCodec_PushInputBuffer(codec_, index), AV_ERR_OK);
258 if (inputFile_->eof()) {
259 isRunning_.store(false);
260 break;
261 }
262 }
263 if (outThread_ != nullptr && outThread_->joinable()) {
264 outThread_->join();
265 }
266 }
267
OutputThread()268 void AudioSyncModeCapiUnitTest::OutputThread()
269 {
270 uint32_t timeoutCnt = 0;
271 for (;;) {
272 uint32_t index = 0;
273 OH_AVErrCode ret = OH_AudioCodec_QueryOutputBuffer(codec_, &index, outTimeout_);
274 if (!isRunning_.load() && timeoutCnt > MAX_OUTPUT_TRY_CNT) {
275 cout << "input end but not EOS output" << endl;
276 break;
277 }
278 if (ret == AV_ERR_TRY_AGAIN_LATER) {
279 cout << "thread output index get timeout" << endl;
280 timeoutCnt++;
281 continue;
282 }
283 timeoutCnt = 0;
284 EXPECT_EQ(ret, AV_ERR_OK);
285 OH_AVBuffer *outputBuf = OH_AudioCodec_GetOutputBuffer(codec_, index);
286 ASSERT_NE(outputBuf, nullptr);
287 OH_AVCodecBufferAttr attr;
288 memset_s(&attr, sizeof(attr), 0, sizeof(attr));
289 ASSERT_EQ(OH_AVBuffer_GetBufferAttr(outputBuf, &attr), AV_ERR_OK);
290 cout << "thread output index:" << index << ", size:" << attr.size << endl;
291 if (attr.flags & AVCODEC_BUFFER_FLAGS_EOS) {
292 cout << "thread output eos" << endl;
293 ASSERT_EQ(OH_AudioCodec_FreeOutputBuffer(codec_, index), AV_ERR_OK);
294 break;
295 }
296 outputFrameCnt_++;
297 outputFile_->write(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(outputBuf)), attr.size);
298 ASSERT_EQ(OH_AudioCodec_FreeOutputBuffer(codec_, index), AV_ERR_OK);
299 }
300 }
301
DecoderFillInputBuffer(OH_AVBuffer * buffer)302 bool AudioSyncModeCapiUnitTest::DecoderFillInputBuffer(OH_AVBuffer *buffer)
303 {
304 OH_AVCodecBufferAttr attr;
305 memset_s(&attr, sizeof(attr), 0, sizeof(attr));
306 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
307 bool finish = true;
308 do {
309 int64_t size;
310 inputFile_->read(reinterpret_cast<char *>(&size), sizeof(size));
311 if (inputFile_->eof() || inputFile_->gcount() != sizeof(size)) {
312 cout << "read size not enough, Set EOS" << endl;
313 break;
314 }
315
316 inputFile_->read(reinterpret_cast<char *>(&attr.pts), sizeof(attr.pts));
317 if (inputFile_->gcount() != sizeof(attr.pts)) {
318 cout << "read pts fail" << endl;
319 break;
320 }
321 attr.size = static_cast<int32_t>(size);
322 if (attr.size > 0) {
323 inputFile_->read((char *)OH_AVBuffer_GetAddr(buffer), attr.size);
324 if (inputFile_->gcount() != attr.size) {
325 cout << "read buffer fail" << endl;
326 break;
327 }
328 attr.flags = AVCODEC_BUFFER_FLAGS_NONE;
329 decodeInputFrameCnt_++;
330 finish = false;
331 }
332 } while (0);
333 EXPECT_EQ(OH_AVBuffer_SetBufferAttr(buffer, &attr), AV_ERR_OK);
334 return finish;
335 }
336
DecoderRun()337 void AudioSyncModeCapiUnitTest::DecoderRun()
338 {
339 ASSERT_EQ(OH_AudioCodec_Prepare(codec_), AV_ERR_OK);
340 ASSERT_EQ(OH_AudioCodec_Start(codec_), AV_ERR_OK);
341 bool inputEnd = false;
342 OH_AVErrCode ret = AV_ERR_OK;
343 for (;;) {
344 uint32_t index = 0;
345 if (!inputEnd) {
346 ret = OH_AudioCodec_QueryInputBuffer(codec_, &index, inTimeout_);
347 if (ret == AV_ERR_TRY_AGAIN_LATER) {
348 continue;
349 }
350 ASSERT_EQ(ret, AV_ERR_OK);
351 OH_AVBuffer *inputBuf = OH_AudioCodec_GetInputBuffer(codec_, index);
352 ASSERT_NE(inputBuf, nullptr);
353 inputEnd = DecoderFillInputBuffer(inputBuf);
354 EXPECT_EQ(OH_AudioCodec_PushInputBuffer(codec_, index), AV_ERR_OK);
355 }
356 ret = OH_AudioCodec_QueryOutputBuffer(codec_, &index, outTimeout_);
357 if (ret == AV_ERR_TRY_AGAIN_LATER) {
358 cout << "output index get timeout" << endl;
359 continue;
360 } else if (ret == AV_ERR_STREAM_CHANGED) {
361 OH_AVFormat *outFormat = OH_AudioCodec_GetOutputDescription(codec_);
362 outputFormatChangedTimes++;
363 OH_AVFormat_GetIntValue(outFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, &outputChannels);
364 OH_AVFormat_GetIntValue(outFormat, OH_MD_KEY_AUD_SAMPLE_RATE, &outputSampleRate);
365 continue;
366 }
367 EXPECT_EQ(ret, AV_ERR_OK);
368 OH_AVBuffer *outputBuf = OH_AudioCodec_GetOutputBuffer(codec_, index);
369 ASSERT_NE(outputBuf, nullptr);
370 OH_AVCodecBufferAttr attr;
371 memset_s(&attr, sizeof(attr), 0, sizeof(attr));
372 ASSERT_EQ(OH_AVBuffer_GetBufferAttr(outputBuf, &attr), AV_ERR_OK);
373 if (attr.flags & AVCODEC_BUFFER_FLAGS_EOS) {
374 cout << "output eos" << endl;
375 ASSERT_EQ(OH_AudioCodec_FreeOutputBuffer(codec_, index), AV_ERR_OK);
376 break;
377 }
378 outputFrameCnt_++;
379 outputFile_->write(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(outputBuf)), attr.size);
380 ASSERT_EQ(OH_AudioCodec_FreeOutputBuffer(codec_, index), AV_ERR_OK);
381 }
382 }
383
DecoderRunIndependentOutput()384 void AudioSyncModeCapiUnitTest::DecoderRunIndependentOutput()
385 {
386 ASSERT_EQ(OH_AudioCodec_Prepare(codec_), AV_ERR_OK);
387 ASSERT_EQ(OH_AudioCodec_Start(codec_), AV_ERR_OK);
388 isRunning_.store(true);
389 outThread_ = make_unique<thread>(&AudioSyncModeCapiUnitTest::OutputThread, this);
390 for (;;) {
391 uint32_t index = 0;
392 OH_AVErrCode ret = OH_AudioCodec_QueryInputBuffer(codec_, &index, inTimeout_);
393 if (ret == AV_ERR_TRY_AGAIN_LATER) {
394 continue;
395 }
396 ASSERT_EQ(ret, AV_ERR_OK);
397 OH_AVBuffer *inputBuf = OH_AudioCodec_GetInputBuffer(codec_, index);
398 ASSERT_NE(inputBuf, nullptr);
399 DecoderFillInputBuffer(inputBuf);
400 EXPECT_EQ(OH_AudioCodec_PushInputBuffer(codec_, index), AV_ERR_OK);
401 if (inputFile_->eof()) {
402 isRunning_.store(false);
403 break;
404 }
405 }
406 if (outThread_ != nullptr && outThread_->joinable()) {
407 outThread_->join();
408 }
409 }
410
411 HWTEST_F(AudioSyncModeCapiUnitTest, aac_encode_01, TestSize.Level1)
412 {
413 inputFile_ = std::make_unique<std::ifstream>(AAC_INPUT_FILE_PATH, std::ios::binary);
414 outputFile_ = std::make_unique<std::ofstream>(AAC_OUTPUT_FILE_PATH, std::ios::binary);
415 ASSERT_EQ(inputFile_->is_open(), true);
416 ASSERT_EQ(outputFile_->is_open(), true);
417
418 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC, true);
419 ASSERT_NE(codec_, nullptr);
420 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
421 EncoderRun();
422 OH_AudioCodec_Destroy(codec_);
423 }
424
425 HWTEST_F(AudioSyncModeCapiUnitTest, aac_encode_02, TestSize.Level1)
426 {
427 inputFile_ = std::make_unique<std::ifstream>(AAC_INPUT_FILE_PATH, std::ios::binary);
428 outputFile_ = std::make_unique<std::ofstream>(AAC_OUTPUT_FILE_PATH, std::ios::binary);
429 ASSERT_EQ(inputFile_->is_open(), true);
430 ASSERT_EQ(outputFile_->is_open(), true);
431
432 codec_ = OH_AudioCodec_CreateByName(std::string(AVCodecCodecName::AUDIO_ENCODER_AAC_NAME).c_str());
433 ASSERT_NE(codec_, nullptr);
434 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
435 EncoderRun();
436 uint32_t needFrames = inputSizeCnt_ / CHANNEL_COUNT / sizeof(int32_t) / AAC_SAMPLE_PER_FRAME + 1;
437 EXPECT_EQ(needFrames, outputFrameCnt_);
438 OH_AudioCodec_Destroy(codec_);
439 }
440
441 HWTEST_F(AudioSyncModeCapiUnitTest, aac_encode_03, TestSize.Level1)
442 {
443 inputFile_ = std::make_unique<std::ifstream>(AAC_INPUT_FILE_PATH, std::ios::binary);
444 outputFile_ = std::make_unique<std::ofstream>(AAC_OUTPUT_FILE_PATH, std::ios::binary);
445 ASSERT_EQ(inputFile_->is_open(), true);
446 ASSERT_EQ(outputFile_->is_open(), true);
447
448 codec_ = OH_AudioCodec_CreateByName(std::string(AVCodecCodecName::AUDIO_ENCODER_VENDOR_AAC_NAME).c_str());
449 if (codec_ != nullptr) {
450 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
451 EncoderRun();
452 uint32_t needFrames = inputSizeCnt_ / CHANNEL_COUNT / sizeof(int32_t) / AAC_SAMPLE_PER_FRAME + 2; // 2:padding
453 EXPECT_EQ(needFrames, outputFrameCnt_);
454 OH_AudioCodec_Destroy(codec_);
455 }
456 }
457
458 HWTEST_F(AudioSyncModeCapiUnitTest, aac_encode_04, TestSize.Level1)
459 {
460 inputFile_ = std::make_unique<std::ifstream>(AAC_INPUT_FILE_PATH, std::ios::binary);
461 outputFile_ = std::make_unique<std::ofstream>(AAC_OUTPUT_FILE_PATH, std::ios::binary);
462 ASSERT_EQ(inputFile_->is_open(), true);
463 ASSERT_EQ(outputFile_->is_open(), true);
464
465 codec_ = OH_AudioCodec_CreateByName(std::string(AVCodecCodecName::AUDIO_ENCODER_AAC_NAME).c_str());
466 ASSERT_NE(codec_, nullptr);
467 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
468 EncoderRunIndependentOutput();
469 uint32_t needFrames = inputSizeCnt_ / CHANNEL_COUNT / sizeof(int32_t) / AAC_SAMPLE_PER_FRAME + 1;
470 EXPECT_EQ(needFrames, outputFrameCnt_);
471 OH_AudioCodec_Destroy(codec_);
472 }
473
474 HWTEST_F(AudioSyncModeCapiUnitTest, flac_encode_01, TestSize.Level1)
475 {
476 inputFile_ = std::make_unique<std::ifstream>(FLAC_INPUT_FILE_PATH, std::ios::binary);
477 outputFile_ = std::make_unique<std::ofstream>(FLAC_OUTPUT_FILE_PATH, std::ios::binary);
478 ASSERT_EQ(inputFile_->is_open(), true);
479 ASSERT_EQ(outputFile_->is_open(), true);
480
481 OH_AVFormat_SetLongValue(format_, OH_MD_KEY_BITRATE, 261000);
482 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_BITS_PER_CODED_SAMPLE, AudioSampleFormat::SAMPLE_S16LE);
483 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioSampleFormat::SAMPLE_S16LE);
484 OH_AVFormat_SetLongValue(format_, OH_MD_KEY_CHANNEL_LAYOUT, AudioChannelLayout::STEREO);
485 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_COMPLIANCE_LEVEL, 0);
486
487 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, true);
488 ASSERT_NE(codec_, nullptr);
489 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
490 EncoderRun();
491 OH_AudioCodec_Destroy(codec_);
492 }
493
494 HWTEST_F(AudioSyncModeCapiUnitTest, g711mu_encode_01, TestSize.Level1)
495 {
496 inputFile_ = std::make_unique<std::ifstream>(G711MU_INPUT_FILE_PATH, std::ios::binary);
497 outputFile_ = std::make_unique<std::ofstream>(G711MU_OUTPUT_FILE_PATH, std::ios::binary);
498 ASSERT_EQ(inputFile_->is_open(), true);
499 ASSERT_EQ(outputFile_->is_open(), true);
500
501 inputFrameBytes_ = G711MU_DEFAULT_FRAME_BYTES;
502 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
503 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, 8000);
504 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioSampleFormat::SAMPLE_S16LE);
505
506 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU, true);
507 ASSERT_NE(codec_, nullptr);
508 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
509 EncoderRun();
510 uint32_t needFrames = inputSizeCnt_ / G711MU_DEFAULT_FRAME_BYTES;
511 EXPECT_EQ(needFrames, outputFrameCnt_);
512 OH_AudioCodec_Destroy(codec_);
513 }
514
515 HWTEST_F(AudioSyncModeCapiUnitTest, opus_encode_01, TestSize.Level1)
516 {
517 if (CheckOpusSoFunc()) {
518 inputFile_ = std::make_unique<std::ifstream>(OPUS_INPUT_FILE_PATH, std::ios::binary);
519 outputFile_ = std::make_unique<std::ofstream>(OPUS_OUTPUT_FILE_PATH, std::ios::binary);
520 ASSERT_EQ(inputFile_->is_open(), true);
521 ASSERT_EQ(outputFile_->is_open(), true);
522
523 inputFrameBytes_ = OPUS_FRAME_SAMPLE_SIZES;
524 OH_AVFormat_SetLongValue(format_, OH_MD_KEY_BITRATE, OPUS_BITS_RATE);
525 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, OPUS_SAMPLE_RATE);
526 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_COMPLIANCE_LEVEL, OPUS_COMPLIANCE_LEVEL);
527 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioSampleFormat::SAMPLE_S16LE);
528
529 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_OPUS, true);
530 ASSERT_NE(codec_, nullptr);
531 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
532 EncoderRun();
533 OH_AudioCodec_Destroy(codec_);
534 }
535 }
536
537 HWTEST_F(AudioSyncModeCapiUnitTest, aac_decode_01, TestSize.Level1)
538 {
539 inputFile_ = std::make_unique<std::ifstream>(INPUT_AAC_FILE_PATH, std::ios::binary);
540 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_AAC_PCM_FILE_PATH, std::ios::binary);
541 ASSERT_EQ(inputFile_->is_open(), true);
542 ASSERT_EQ(outputFile_->is_open(), true);
543
544 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC, false);
545 ASSERT_NE(codec_, nullptr);
546 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AAC_IS_ADTS, 1);
547 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
548 DecoderRun();
549 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
550 OH_AudioCodec_Destroy(codec_);
551 }
552
553 HWTEST_F(AudioSyncModeCapiUnitTest, aac_decode_02, TestSize.Level1)
554 {
555 inputFile_ = std::make_unique<std::ifstream>(INPUT_AAC_FILE_PATH, std::ios::binary);
556 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_AAC_PCM_FILE_PATH, std::ios::binary);
557 ASSERT_EQ(inputFile_->is_open(), true);
558 ASSERT_EQ(outputFile_->is_open(), true);
559
560 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC, false);
561 ASSERT_NE(codec_, nullptr);
562 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AAC_IS_ADTS, 1);
563 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
564 DecoderRunIndependentOutput();
565 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
566 OH_AudioCodec_Destroy(codec_);
567 }
568
569 HWTEST_F(AudioSyncModeCapiUnitTest, flac_decode_01, TestSize.Level1)
570 {
571 inputFile_ = std::make_unique<std::ifstream>(INPUT_FLAC_FILE_PATH, std::ios::binary);
572 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_FLAC_PCM_FILE_PATH, std::ios::binary);
573 ASSERT_EQ(inputFile_->is_open(), true);
574 ASSERT_EQ(outputFile_->is_open(), true);
575
576 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, false);
577 ASSERT_NE(codec_, nullptr);
578 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
579 DecoderRun();
580 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
581 OH_AudioCodec_Destroy(codec_);
582 }
583
584 HWTEST_F(AudioSyncModeCapiUnitTest, flac_decode_02, TestSize.Level1)
585 {
586 inputFile_ = std::make_unique<std::ifstream>(INPUT_FLAC_FILE_PATH, std::ios::binary);
587 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_FLAC_PCM_FILE_PATH, std::ios::binary);
588 ASSERT_EQ(inputFile_->is_open(), true);
589 ASSERT_EQ(outputFile_->is_open(), true);
590 inTimeout_ = -2;
591 outTimeout_ = -10;
592
593 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, false);
594 ASSERT_NE(codec_, nullptr);
595 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
596 DecoderRun();
597 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
598 OH_AudioCodec_Destroy(codec_);
599 }
600
601 HWTEST_F(AudioSyncModeCapiUnitTest, amrnb_decode_01, TestSize.Level1)
602 {
603 inputFile_ = std::make_unique<std::ifstream>(INPUT_AMRNB_FILE_PATH, std::ios::binary);
604 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_AMRNB_PCM_FILE_PATH, std::ios::binary);
605 ASSERT_EQ(inputFile_->is_open(), true);
606 ASSERT_EQ(outputFile_->is_open(), true);
607
608 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB, false);
609 ASSERT_NE(codec_, nullptr);
610 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
611 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, 8000);
612 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
613 DecoderRun();
614 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
615 OH_AudioCodec_Destroy(codec_);
616 }
617
618 HWTEST_F(AudioSyncModeCapiUnitTest, amrwb_decode_01, TestSize.Level1)
619 {
620 inputFile_ = std::make_unique<std::ifstream>(INPUT_AMRWB_FILE_PATH, std::ios::binary);
621 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_AMRWB_PCM_FILE_PATH, std::ios::binary);
622 ASSERT_EQ(inputFile_->is_open(), true);
623 ASSERT_EQ(outputFile_->is_open(), true);
624
625 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB, false);
626 ASSERT_NE(codec_, nullptr);
627 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
628 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, 16000);
629 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
630 DecoderRun();
631 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
632 OH_AudioCodec_Destroy(codec_);
633 }
634
635 HWTEST_F(AudioSyncModeCapiUnitTest, g711mu_decode_01, TestSize.Level1)
636 {
637 inputFile_ = std::make_unique<std::ifstream>(INPUT_G711MU_FILE_PATH, std::ios::binary);
638 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_G711MU_PCM_FILE_PATH, std::ios::binary);
639 ASSERT_EQ(inputFile_->is_open(), true);
640 ASSERT_EQ(outputFile_->is_open(), true);
641
642 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU, false);
643 ASSERT_NE(codec_, nullptr);
644 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
645 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, 8000);
646 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
647 DecoderRun();
648 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
649 OH_AudioCodec_Destroy(codec_);
650 }
651
652 HWTEST_F(AudioSyncModeCapiUnitTest, ape_decode_01, TestSize.Level1)
653 {
654 inputFile_ = std::make_unique<std::ifstream>(INPUT_APE_FILE_PATH, std::ios::binary);
655 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_APE_PCM_FILE_PATH, std::ios::binary);
656 ASSERT_EQ(inputFile_->is_open(), true);
657 ASSERT_EQ(outputFile_->is_open(), true);
658
659 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_APE, false);
660 ASSERT_NE(codec_, nullptr);
661 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
662 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, 8000);
663 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
664 DecoderRun();
665 OH_AudioCodec_Destroy(codec_);
666 }
667
668 HWTEST_F(AudioSyncModeCapiUnitTest, mp3_decode_01, TestSize.Level1)
669 {
670 inputFile_ = std::make_unique<std::ifstream>(INPUT_MP3_FILE_PATH, std::ios::binary);
671 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_MP3_PCM_FILE_PATH, std::ios::binary);
672 ASSERT_EQ(inputFile_->is_open(), true);
673 ASSERT_EQ(outputFile_->is_open(), true);
674
675 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, false);
676 ASSERT_NE(codec_, nullptr);
677 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
678 DecoderRun();
679 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
680 OH_AudioCodec_Destroy(codec_);
681 }
682
683 HWTEST_F(AudioSyncModeCapiUnitTest, vorbis_decode_01, TestSize.Level1)
684 {
685 inputFile_ = std::make_unique<std::ifstream>(INPUT_VORBIS_FILE_PATH, std::ios::binary);
686 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_VORBIS_PCM_FILE_PATH, std::ios::binary);
687 ASSERT_EQ(inputFile_->is_open(), true);
688 ASSERT_EQ(outputFile_->is_open(), true);
689
690 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, false);
691 ASSERT_NE(codec_, nullptr);
692 int64_t extradataSize;
693 inputFile_->read(reinterpret_cast<char *>(&extradataSize), sizeof(int64_t));
694 ASSERT_EQ(inputFile_->gcount(), sizeof(int64_t));
695 ASSERT_EQ(extradataSize > 0, true);
696 char buffer[extradataSize];
697 inputFile_->read(buffer, extradataSize);
698 ASSERT_EQ(inputFile_->gcount(), extradataSize);
699 OH_AVFormat_SetBuffer(format_, OH_MD_KEY_CODEC_CONFIG, (uint8_t *)buffer, extradataSize);
700 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
701 DecoderRun();
702 // vorbis decode check output less than input frame
703 OH_AudioCodec_Destroy(codec_);
704 }
705
706 HWTEST_F(AudioSyncModeCapiUnitTest, opus_decode_01, TestSize.Level1)
707 {
708 if (CheckOpusSoFunc()) {
709 inputFile_ = std::make_unique<std::ifstream>(INPUT_OPUS_FILE_PATH, std::ios::binary);
710 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_OPUS_PCM_FILE_PATH, std::ios::binary);
711 ASSERT_EQ(inputFile_->is_open(), true);
712 ASSERT_EQ(outputFile_->is_open(), true);
713
714 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_OPUS, false);
715 ASSERT_NE(codec_, nullptr);
716 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, 8000);
717 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
718 DecoderRun();
719 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
720 OH_AudioCodec_Destroy(codec_);
721 }
722 }
723
724 HWTEST_F(AudioSyncModeCapiUnitTest, aaclc_decode_formatchanged, TestSize.Level1)
725 {
726 inputFile_ = std::make_unique<std::ifstream>(INPUT_AAC_LC_ADTS_FILE_PATH, std::ios::binary);
727 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_AAC_LC_ADTS_FILE_PATH, std::ios::binary);
728 ASSERT_EQ(inputFile_->is_open(), true);
729 ASSERT_EQ(outputFile_->is_open(), true);
730
731 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC, false);
732 ASSERT_NE(codec_, nullptr);
733 OH_AVFormat_SetIntValue(format_, OH_MD_KEY_AUD_SAMPLE_RATE, 8000);
734 ASSERT_EQ(OH_AudioCodec_Configure(codec_, format_), AV_ERR_OK);
735 DecoderRun();
736 EXPECT_EQ(outputFormatChangedTimes, 1);
737 EXPECT_EQ(outputSampleRate, SAMPLE_RATE);
738 EXPECT_EQ(outputChannels, CHANNEL_COUNT);
739 EXPECT_EQ(decodeInputFrameCnt_, outputFrameCnt_);
740 OH_AudioCodec_Destroy(codec_);
741 }
742
743 HWTEST_F(AudioSyncModeCapiUnitTest, sync_invalid_01, TestSize.Level1)
744 {
745 codec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC, false);
746 ASSERT_NE(codec_, nullptr);
747 uint32_t index = 0;
748 EXPECT_EQ(OH_AudioCodec_QueryInputBuffer(codec_, &index, 1000), AV_ERR_INVALID_STATE);
749 EXPECT_EQ(OH_AudioCodec_QueryOutputBuffer(codec_, &index, 1000), AV_ERR_INVALID_STATE);
750 EXPECT_EQ(OH_AudioCodec_GetInputBuffer(codec_, 0), nullptr);
751 EXPECT_EQ(OH_AudioCodec_GetOutputBuffer(codec_, 0), nullptr);
752 EXPECT_EQ(OH_AudioCodec_QueryInputBuffer(codec_, nullptr, 1000), AV_ERR_INVALID_VAL);
753 EXPECT_EQ(OH_AudioCodec_QueryOutputBuffer(codec_, nullptr, 1000), AV_ERR_INVALID_VAL);
754 OH_AudioCodec_Destroy(codec_);
755
756 OH_AVCodec *invalidCodec = OH_AudioCodec_CreateByMime("invalid mime", false);
757 EXPECT_EQ(OH_AudioCodec_QueryInputBuffer(invalidCodec, &index, 1000), AV_ERR_INVALID_VAL);
758 EXPECT_EQ(OH_AudioCodec_QueryOutputBuffer(invalidCodec, &index, 1000), AV_ERR_INVALID_VAL);
759 }
760
761 }
762 }
763