1 /*
2 * Copyright (C) 2023 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 "avcodec_codec_name.h"
28 #include "avcodec_common.h"
29 #include "avcodec_errors.h"
30 #include "media_description.h"
31 #include "native_avcodec_base.h"
32 #include "native_avformat.h"
33 #include "native_avcodec_audiodecoder.h"
34 #include "securec.h"
35
36 using namespace std;
37 using namespace testing::ext;
38 using namespace OHOS::MediaAVCodec;
39
40 namespace {
41 const string CODEC_MP3_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_MP3_NAME);
42 const string CODEC_AAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_AAC_NAME);
43 const string CODEC_OGG_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME);
44 const string CODEC_FLAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_FLAC_NAME);
45 const string CODEC_AMRWB_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_AMRWB_NAME);
46 const string CODEC_AMRNB_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_AMRNB_NAME);
47 const string CODEC_OPUS_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_OPUS_NAME);
48 const string CODEC_G711MU_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_G711MU_NAME);
49 const string INPUT_SOURCE_PATH = "/data/test/media/";
50 const string OPUS_SO_FILE_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_ext_base.z.so";
51 const int MP3_TESTCASES_NUMS = 15;
52 const int FLAC_TESTCASES_NUMS = 8;
53 const int OGG_TESTCASES_NUMS = 11;
54 const int AAC_TESTCASES_NUMS = 6;
55
56 const string INPUT_MP3_FILE_SOURCE_PATH[][5] = {{"MP3_11k_2c_20kb.dat", "11025", "2", "32000", "16"},
57 {"MP3_16k_2c_32kb.dat", "16000", "2", "32000", "16"},
58 {"MP3_16k_2c_40kb.dat", "16000", "2", "40000", "16"},
59 {"MP3_22k_1c_32kb.dat", "22050", "1", "32000", "16"},
60 {"MP3_24k_2c_80kb.dat", "24000", "2", "80000", "16"},
61 {"MP3_44k_1c_128kb.dat", "44100", "1", "128000", "16"},
62 {"MP3_44k_2c_128kb.dat", "44100", "2", "128000", "16"},
63 {"MP3_44k_2c_160kb.dat", "44100", "2", "160000", "16"},
64 {"MP3_44k_2c_320kb.dat", "44100", "2", "320000", "16"},
65 {"MP3_48k_1c_128kb.dat", "48000", "1", "128000", "16"},
66 {"MP3_48k_1c_320kb.dat", "48000", "1", "320000", "16"},
67 {"MP3_48k_2c_320kb.dat", "48000", "2", "320000", "16"},
68 {"MP3_8k_1c_8kb.dat", "8000", "1", "32000", "16"},
69 {"MP3_8k_2c_16kb.dat", "16000", "2", "32000", "16"},
70 {"MP3_8k_2c_18kb.dat", "16000", "2", "32000", "16"}};
71
72 const string INPUT_FLAC_FILE_SOURCE_PATH[][5] = {{"FLAC_6k_1c_xxkb.dat", "8000", "1", "320000", "16"},
73 {"FLAC_6k_2c_xxkb.dat", "8000", "2", "320000", "16"},
74 {"FLAC_6k_3c_xxkb.dat", "8000", "3", "320000", "16"},
75 {"FLAC_6k_4c_xxkb.dat", "8000", "4", "320000", "16"},
76 {"FLAC_6k_5c_xxkb.dat", "8000", "5", "320000", "16"},
77 {"FLAC_6k_6c_xxkb.dat", "8000", "6", "320000", "16"},
78 {"FLAC_6k_7c_xxkb.dat", "8000", "7", "320000", "16"},
79 {"FLAC_6k_8c_xxkb.dat", "8000", "8", "320000", "16"}};
80
81 const string INPUT_OGG_FILE_SOURCE_PATH[][5] = {{"OGG_192k_1c_100pkb.dat", "176400", "1", "320000", "16"},
82 {"OGG_192k_1c_xxkb.dat", "176400", "1", "320000", "16"},
83 {"OGG_192k_2c_xxkb.dat", "176400", "2", "320000", "16"},
84 {"OGG_192k_3c_xxkb.dat", "192000", "3", "320000", "16"},
85 {"OGG_192k_4c_xxkb.dat", "192000", "4", "320000", "16"},
86 {"OGG_192k_5c_xxkb.dat", "192000", "5", "320000", "16"},
87 {"OGG_192k_6c_xxkb.dat", "192000", "6", "320000", "16"},
88 {"OGG_192k_7c_xxkb.dat", "192000", "7", "320000", "16"},
89 {"OGG_192k_8c_xxkb.dat", "192000", "8", "320000", "16"},
90 {"OGG_8k_1c_0pkb.dat", "8000", "1", "32000", "16"},
91 {"OGG_8k_1c_100pkb.dat", "8000", "1", "32000", "16"}};
92
93 const string INPUT_OGG_FILE_WITH_HEADER[][5] = {{"OGG_44k_2c_with_header.dat", "44100", "2", "128000", "16"}};
94
95 const string INPUT_AAC_FILE_SOURCE_PATH[][5] = {{"AAC_44k_1c_xxkb.dat", "44100", "1", "32000", "16"},
96 {"AAC_44k_2c_xxkb.dat", "44100", "2", "320000", "16"},
97 {"AAC_44k_6c_xxkb.dat", "44100", "6", "320000", "16"},
98 {"AAC_48k_1c_xxkb.dat", "48000", "1", "320000", "16"},
99 {"AAC_48k_2c_xxkb.dat", "48000", "2", "320000", "16"},
100 {"AAC_48k_6c_xxkb.dat", "48000", "6", "192000", "16"}};
101
102 std::vector<std::vector<string>> INPUT_AMRWB_FILE_SOURCE_PATH = {{"voice_amrwb_6600.dat", "16000", "1"},
103 {"voice_amrwb_8850.dat", "16000", "1"},
104 {"voice_amrwb_12650.dat", "16000", "1"},
105 {"voice_amrwb_14250.dat", "16000", "1"},
106 {"voice_amrwb_15850.dat", "16000", "1"},
107 {"voice_amrwb_18250.dat", "16000", "1"},
108 {"voice_amrwb_19850.dat", "16000", "1"},
109 {"voice_amrwb_23050.dat", "16000", "1"},
110 {"voice_amrwb_23850.dat", "16000", "1"}};
111
112 std::vector<std::vector<string>> INPUT_AMRNB_FILE_SOURCE_PATH = {{"voice_amrnb_4750.dat", "8000", "1"},
113 {"voice_amrnb_5150.dat", "8000", "1"},
114 {"voice_amrnb_5900.dat", "8000", "1"},
115 {"voice_amrnb_6700.dat", "8000", "1"},
116 {"voice_amrnb_7400.dat", "8000", "1"},
117 {"voice_amrnb_7950.dat", "8000", "1"},
118 {"voice_amrnb_10200.dat", "8000", "1"},
119 {"voice_amrnb_12200.dat", "8000", "1"}};
120
121 std::vector<std::vector<string>> INPUT_OPUS_FILE_SOURCE_PATH = {{"voice_opus.dat", "8000", "1"},
122 {"voice_opus.dat", "12000", "1"},
123 {"voice_opus.dat", "16000", "1"},
124 {"voice_opus.dat", "24000", "1"},
125 {"voice_opus.dat", "48000", "1"},
126 {"voice_opus.dat", "8000", "2"},
127 {"voice_opus.dat", "16000", "2"},
128 {"voice_opus.dat", "48000", "2"}};
129
130 std::vector<std::vector<string>> INPUT_G711MU_FILE_SOURCE_PATH = {{"g711mu_8kHz.dat", "8000", "1"}};
131 constexpr string_view OUTPUT_PCM_FILE_PATH = "/data/test/media/out.pcm";
132 } // namespace
133
134 namespace OHOS {
135 namespace MediaAVCodec {
136 class ADecSignal {
137 public:
138 std::mutex inMutex_;
139 std::mutex outMutex_;
140 std::mutex startMutex_;
141 std::condition_variable inCond_;
142 std::condition_variable outCond_;
143 std::condition_variable startCond_;
144 std::queue<uint32_t> inQueue_;
145 std::queue<uint32_t> outQueue_;
146 std::queue<OH_AVMemory *> inBufferQueue_;
147 std::queue<OH_AVMemory *> outBufferQueue_;
148 std::queue<OH_AVCodecBufferAttr> attrQueue_;
149 };
150
OnError(OH_AVCodec * codec,int32_t errorCode,void * userData)151 static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData)
152 {
153 (void)codec;
154 (void)errorCode;
155 (void)userData;
156 cout << "Error received, errorCode:" << errorCode << endl;
157 }
158
OnOutputFormatChanged(OH_AVCodec * codec,OH_AVFormat * format,void * userData)159 static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData)
160 {
161 (void)codec;
162 (void)format;
163 (void)userData;
164 cout << "OnOutputFormatChanged received" << endl;
165 }
166
OnInputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,void * userData)167 static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, void *userData)
168 {
169 (void)codec;
170 ADecSignal *signal = static_cast<ADecSignal *>(userData);
171 unique_lock<mutex> lock(signal->inMutex_);
172 signal->inQueue_.push(index);
173 signal->inBufferQueue_.push(data);
174 signal->inCond_.notify_all();
175 }
176
OnOutputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,OH_AVCodecBufferAttr * attr,void * userData)177 static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, OH_AVCodecBufferAttr *attr,
178 void *userData)
179 {
180 (void)codec;
181 ADecSignal *signal = static_cast<ADecSignal *>(userData);
182 unique_lock<mutex> lock(signal->outMutex_);
183 signal->outQueue_.push(index);
184 signal->outBufferQueue_.push(data);
185 if (attr) {
186 signal->attrQueue_.push(*attr);
187 } else {
188 cout << "OnOutputBufferAvailable error, attr is nullptr!" << endl;
189 }
190 signal->outCond_.notify_all();
191 }
192
193 class AudioCodeCapiDecoderUnitTest : public testing::Test {
194 public:
195 static void SetUpTestCase(void);
196 static void TearDownTestCase(void);
197 void SetUp();
198 void TearDown();
199 int32_t InitFile(const string &codecName, string inputTestFile);
200 void InputFunc();
201 void OutputFunc();
202 void HandleInputEOS(const uint32_t index);
203 int32_t HandleNormalInput(const uint32_t &index, const int64_t pts, const size_t size);
204 int32_t Stop();
205 void Release();
206 int32_t SetVorbisHeader();
207 int32_t CheckSoFunc();
208
209 protected:
210 std::unique_ptr<std::ifstream> soFile_;
211 std::atomic<bool> isRunning_ = false;
212 std::unique_ptr<std::thread> inputLoop_;
213 std::unique_ptr<std::thread> outputLoop_;
214 struct OH_AVCodecAsyncCallback cb_;
215 ADecSignal *signal_;
216 OH_AVCodec *audioDec_;
217 OH_AVFormat *format_;
218 bool isFirstFrame_ = true;
219 std::ifstream inputFile_;
220 std::ofstream pcmOutputFile_;
221 bool vorbisHasExtradata_ = true;
222 };
223
SetUpTestCase(void)224 void AudioCodeCapiDecoderUnitTest::SetUpTestCase(void)
225 {
226 cout << "[SetUpTestCase]: " << endl;
227 }
228
TearDownTestCase(void)229 void AudioCodeCapiDecoderUnitTest::TearDownTestCase(void)
230 {
231 cout << "[TearDownTestCase]: " << endl;
232 }
233
SetUp(void)234 void AudioCodeCapiDecoderUnitTest::SetUp(void)
235 {
236 cout << "[SetUp]: SetUp!!!" << endl;
237 }
238
TearDown(void)239 void AudioCodeCapiDecoderUnitTest::TearDown(void)
240 {
241 cout << "[TearDown]: over!!!" << endl;
242
243 if (signal_) {
244 delete signal_;
245 signal_ = nullptr;
246 }
247 if (inputFile_.is_open()) {
248 inputFile_.close();
249 }
250 if (pcmOutputFile_.is_open()) {
251 pcmOutputFile_.close();
252 }
253 sleep(1);
254 }
255
Release()256 void AudioCodeCapiDecoderUnitTest::Release()
257 {
258 Stop();
259 if (signal_) {
260 delete signal_;
261 signal_ = nullptr;
262 }
263 if (inputFile_.is_open()) {
264 inputFile_.close();
265 }
266 if (pcmOutputFile_.is_open()) {
267 pcmOutputFile_.close();
268 }
269 if (format_) {
270 OH_AVFormat_Destroy(format_);
271 }
272 OH_AudioDecoder_Destroy(audioDec_);
273 }
274
HandleInputEOS(const uint32_t index)275 void AudioCodeCapiDecoderUnitTest::HandleInputEOS(const uint32_t index)
276 {
277 OH_AVCodecBufferAttr info;
278 info.size = 0;
279 info.offset = 0;
280 info.pts = 0;
281 info.flags = AVCODEC_BUFFER_FLAGS_EOS;
282 OH_AudioDecoder_PushInputData(audioDec_, index, info);
283 signal_->inBufferQueue_.pop();
284 signal_->inQueue_.pop();
285 }
286
HandleNormalInput(const uint32_t & index,const int64_t pts,const size_t size)287 int32_t AudioCodeCapiDecoderUnitTest::HandleNormalInput(const uint32_t &index, const int64_t pts, const size_t size)
288 {
289 OH_AVCodecBufferAttr info;
290 info.size = size;
291 info.offset = 0;
292 info.pts = pts;
293
294 int32_t ret = AV_ERR_OK;
295 if (isFirstFrame_) {
296 info.flags = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
297 ret = OH_AudioDecoder_PushInputData(audioDec_, index, info);
298 EXPECT_EQ(AV_ERR_OK, ret);
299 isFirstFrame_ = false;
300 } else {
301 info.flags = AVCODEC_BUFFER_FLAGS_NONE;
302 ret = OH_AudioDecoder_PushInputData(audioDec_, index, info);
303 EXPECT_EQ(AV_ERR_OK, ret);
304 }
305 signal_->inQueue_.pop();
306 signal_->inBufferQueue_.pop();
307 return ret;
308 }
309
InputFunc()310 void AudioCodeCapiDecoderUnitTest::InputFunc()
311 {
312 int64_t size;
313 int64_t pts;
314
315 while (isRunning_.load()) {
316 unique_lock<mutex> lock(signal_->inMutex_);
317 signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
318
319 if (!isRunning_.load()) {
320 break;
321 }
322
323 uint32_t index = signal_->inQueue_.front();
324 auto buffer = signal_->inBufferQueue_.front();
325 if (buffer == nullptr) {
326 cout << "Fatal: GetInputBuffer fail" << endl;
327 break;
328 }
329 inputFile_.read(reinterpret_cast<char *>(&size), sizeof(size));
330 if (inputFile_.eof() || inputFile_.gcount() == 0) {
331 HandleInputEOS(index);
332 cout << "end buffer\n";
333 break;
334 }
335 if (inputFile_.gcount() != sizeof(size)) {
336 cout << "Fatal: read size fail" << endl;
337 break;
338 }
339 inputFile_.read(reinterpret_cast<char *>(&pts), sizeof(pts));
340 if (inputFile_.gcount() != sizeof(pts)) {
341 cout << "Fatal: read size fail" << endl;
342 break;
343 }
344 inputFile_.read((char *)OH_AVMemory_GetAddr(buffer), size);
345 if (inputFile_.gcount() != size) {
346 cout << "Fatal: read buffer fail" << endl;
347 break;
348 }
349
350 int32_t ret = HandleNormalInput(index, pts, size);
351 if (ret != AV_ERR_OK) {
352 cout << "Fatal error, exit" << endl;
353 break;
354 }
355 }
356 inputFile_.close();
357 }
358
OutputFunc()359 void AudioCodeCapiDecoderUnitTest::OutputFunc()
360 {
361 if (!pcmOutputFile_.is_open()) {
362 std::cout << "open " << OUTPUT_PCM_FILE_PATH << " failed!" << std::endl;
363 }
364 while (isRunning_.load()) {
365 unique_lock<mutex> lock(signal_->outMutex_);
366 signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
367
368 if (!isRunning_.load()) {
369 cout << "wait to stop, exit" << endl;
370 break;
371 }
372
373 uint32_t index = signal_->outQueue_.front();
374 OH_AVCodecBufferAttr attr = signal_->attrQueue_.front();
375 OH_AVMemory *data = signal_->outBufferQueue_.front();
376 if (data != nullptr) {
377 pcmOutputFile_.write(reinterpret_cast<char *>(OH_AVMemory_GetAddr(data)), attr.size);
378 }
379
380 if (attr.flags == AVCODEC_BUFFER_FLAGS_EOS) {
381 cout << "decode eos" << endl;
382 isRunning_.store(false);
383 signal_->startCond_.notify_all();
384 }
385 signal_->outBufferQueue_.pop();
386 signal_->attrQueue_.pop();
387 signal_->outQueue_.pop();
388 EXPECT_EQ(AV_ERR_OK, OH_AudioDecoder_FreeOutputData(audioDec_, index));
389 }
390
391 pcmOutputFile_.close();
392 }
393
Stop()394 int32_t AudioCodeCapiDecoderUnitTest::Stop()
395 {
396 isRunning_.store(false);
397 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
398 unique_lock<mutex> lock(signal_->inMutex_);
399 signal_->inCond_.notify_all();
400 lock.unlock();
401 inputLoop_->join();
402 }
403
404 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
405 unique_lock<mutex> lock(signal_->outMutex_);
406 signal_->outCond_.notify_all();
407 lock.unlock();
408 outputLoop_->join();
409 }
410 return OH_AudioDecoder_Stop(audioDec_);
411 }
412
SetVorbisHeader()413 int32_t AudioCodeCapiDecoderUnitTest::SetVorbisHeader()
414 {
415 // set identification header
416 int64_t headerSize;
417 inputFile_.read(reinterpret_cast<char *>(&headerSize), sizeof(int64_t));
418 if (headerSize < 0) {
419 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
420 }
421 char idBuffer[headerSize];
422 inputFile_.read(idBuffer, headerSize);
423 if (inputFile_.gcount() != headerSize) {
424 cout << "read extradata bytes error" << endl;
425 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
426 }
427 OH_AVFormat_SetBuffer(format_, MediaDescriptionKey::MD_KEY_IDENTIFICATION_HEADER.data(), (uint8_t *)idBuffer,
428 headerSize);
429
430 // set setup header
431 inputFile_.read(reinterpret_cast<char *>(&headerSize), sizeof(int64_t));
432 if (headerSize < 0) {
433 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
434 }
435 char setupBuffer[headerSize];
436 inputFile_.read(setupBuffer, headerSize);
437 if (inputFile_.gcount() != headerSize) {
438 cout << "read extradata bytes error" << endl;
439 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
440 }
441 OH_AVFormat_SetBuffer(format_, MediaDescriptionKey::MD_KEY_SETUP_HEADER.data(), (uint8_t *)setupBuffer,
442 headerSize);
443 return AVCodecServiceErrCode::AVCS_ERR_OK;
444 }
445
CheckSoFunc()446 int32_t AudioCodeCapiDecoderUnitTest::CheckSoFunc()
447 {
448 soFile_ = std::make_unique<std::ifstream>(OPUS_SO_FILE_PATH, std::ios::binary);
449 if (!soFile_->is_open()) {
450 cout << "Fatal: Open so file failed" << endl;
451 return false;
452 }
453 soFile_->close();
454 return true;
455 }
456
InitFile(const string & codecName,string inputTestFile)457 int32_t AudioCodeCapiDecoderUnitTest::InitFile(const string &codecName, string inputTestFile)
458 {
459 format_ = OH_AVFormat_Create();
460 if (codecName.compare(CODEC_AAC_NAME) == 0) {
461 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AAC_IS_ADTS.data(), 1);
462 }
463 audioDec_ = OH_AudioDecoder_CreateByName(codecName.c_str());
464 if (audioDec_ == nullptr) {
465 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
466 }
467
468 inputFile_.open(INPUT_SOURCE_PATH + inputTestFile, std::ios::binary);
469 pcmOutputFile_.open(OUTPUT_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary);
470 if (!inputFile_.is_open()) {
471 cout << "Fatal: open input file failed" << endl;
472 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
473 }
474 if (!pcmOutputFile_.is_open()) {
475 cout << "Fatal: open output file failed" << endl;
476 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
477 }
478
479 signal_ = new ADecSignal();
480 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
481 int32_t ret = OH_AudioDecoder_SetCallback(audioDec_, cb_, signal_);
482 if (ret != AVCodecServiceErrCode::AVCS_ERR_OK) {
483 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
484 }
485
486 if (codecName.compare(CODEC_OGG_NAME) == 0) {
487 if (!vorbisHasExtradata_) {
488 return SetVorbisHeader();
489 }
490 int64_t extradataSize;
491 inputFile_.read(reinterpret_cast<char *>(&extradataSize), sizeof(int64_t));
492 if (extradataSize < 0) {
493 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
494 }
495 char buffer[extradataSize];
496 inputFile_.read(buffer, extradataSize);
497 if (inputFile_.gcount() != extradataSize) {
498 cout << "read extradata bytes error" << endl;
499 }
500 OH_AVFormat_SetBuffer(format_, MediaDescriptionKey::MD_KEY_CODEC_CONFIG.data(), (uint8_t *)buffer,
501 extradataSize);
502 }
503
504 return AVCodecServiceErrCode::AVCS_ERR_OK;
505 }
506
507 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Normalcase_01, TestSize.Level1)
508 {
509 bool result;
510 for (int i = 0; i < MP3_TESTCASES_NUMS; i++) {
511 cout << "decode start " << INPUT_MP3_FILE_SOURCE_PATH[i][0] << endl;
512 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_MP3_NAME, INPUT_MP3_FILE_SOURCE_PATH[i][0]));
513
514 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
515 stoi(INPUT_MP3_FILE_SOURCE_PATH[i][1]));
516 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
517 stoi(INPUT_MP3_FILE_SOURCE_PATH[i][2]));
518 OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(),
519 stol(INPUT_MP3_FILE_SOURCE_PATH[i][3]));
520 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(),
521 stoi(INPUT_MP3_FILE_SOURCE_PATH[i][4]));
522 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), (uint32_t)16);
523
524 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
525
526 isRunning_.store(true);
527 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
528 EXPECT_NE(nullptr, inputLoop_);
529 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
530 EXPECT_NE(nullptr, outputLoop_);
531
532 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
533 {
534 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50402() 535 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
536 }
537 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
538 result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
539 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_MP3_FILE_SOURCE_PATH[i][0] << endl;
540
541 Release();
542 }
543 }
544
545 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Normalcase_02, TestSize.Level1)
546 {
547 bool result;
548 for (int i = 0; i < FLAC_TESTCASES_NUMS; i++) {
549 cout << "decode start " << INPUT_FLAC_FILE_SOURCE_PATH[i][0] << endl;
550 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_FLAC_NAME, INPUT_FLAC_FILE_SOURCE_PATH[i][0]));
551 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
552 stoi(INPUT_FLAC_FILE_SOURCE_PATH[i][1]));
553 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
554 stoi(INPUT_FLAC_FILE_SOURCE_PATH[i][2]));
555 OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(),
556 stol(INPUT_FLAC_FILE_SOURCE_PATH[i][3]));
557 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(),
558 stoi(INPUT_FLAC_FILE_SOURCE_PATH[i][4]));
559
560 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
561
562 isRunning_.store(true);
563 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
564 EXPECT_NE(nullptr, inputLoop_);
565 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
566 EXPECT_NE(nullptr, outputLoop_);
567
568 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
569 {
570 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50502() 571 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
572 }
573 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
574 result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
575 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_FLAC_FILE_SOURCE_PATH[i][0] << endl;
576
577 Release();
578 }
579 }
580
581 HWTEST_F(AudioCodeCapiDecoderUnitTest, oggDecodeWithHeader, TestSize.Level1)
582 {
583 cout << "decode start " << INPUT_OGG_FILE_WITH_HEADER[0][0] << endl;
584 vorbisHasExtradata_ = false;
585 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_OGG_NAME, INPUT_OGG_FILE_WITH_HEADER[0][0]));
586 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
587 stoi(INPUT_OGG_FILE_WITH_HEADER[0][1]));
588 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
589 stoi(INPUT_OGG_FILE_WITH_HEADER[0][2]));
590 OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(),
591 stol(INPUT_OGG_FILE_WITH_HEADER[0][3]));
592 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
593
594 isRunning_.store(true);
595 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
596 EXPECT_NE(nullptr, inputLoop_);
597 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
598 EXPECT_NE(nullptr, outputLoop_);
599
600 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
601 {
602 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50602() 603 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
604 }
605 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
606 auto result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
607 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_OGG_FILE_WITH_HEADER[0][0] << endl;
608
609 Release();
610 }
611
612 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Normalcase_03, TestSize.Level1)
613 {
614 vorbisHasExtradata_ = true;
615 bool result;
616 for (int i = 0; i < OGG_TESTCASES_NUMS; i++) {
617 cout << "decode start " << INPUT_OGG_FILE_SOURCE_PATH[i][0] << endl;
618 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_OGG_NAME, INPUT_OGG_FILE_SOURCE_PATH[i][0]));
619
620 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
621 stoi(INPUT_OGG_FILE_SOURCE_PATH[i][1]));
622 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
623 stoi(INPUT_OGG_FILE_SOURCE_PATH[i][2]));
624 OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(),
625 stol(INPUT_OGG_FILE_SOURCE_PATH[i][3]));
626 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(),
627 stoi(INPUT_OGG_FILE_SOURCE_PATH[i][4]));
628 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
629
630 isRunning_.store(true);
631 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
632 EXPECT_NE(nullptr, inputLoop_);
633 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
634 EXPECT_NE(nullptr, outputLoop_);
635
636 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
637 {
638 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50702() 639 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
640 }
641 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
642 result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
643 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_OGG_FILE_SOURCE_PATH[i][0] << endl;
644
645 Release();
646 }
647 }
648
649 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Normalcase_04, TestSize.Level1)
650 {
651 bool result;
652 for (int i = 0; i < AAC_TESTCASES_NUMS; i++) {
653 cout << "decode start " << INPUT_AAC_FILE_SOURCE_PATH[i][0] << endl;
654 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_AAC_NAME, INPUT_AAC_FILE_SOURCE_PATH[i][0]));
655
656 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
657 stoi(INPUT_AAC_FILE_SOURCE_PATH[i][1]));
658 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
659 stoi(INPUT_AAC_FILE_SOURCE_PATH[i][2]));
660 OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(),
661 stol(INPUT_AAC_FILE_SOURCE_PATH[i][3]));
662 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(),
663 stoi(INPUT_AAC_FILE_SOURCE_PATH[i][4]));
664
665 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
666
667 isRunning_.store(true);
668 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
669 EXPECT_NE(nullptr, inputLoop_);
670 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
671 EXPECT_NE(nullptr, outputLoop_);
672
673 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
674 {
675 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50802() 676 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
677 }
678 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
679 result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
680 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_AAC_FILE_SOURCE_PATH[i][0] << endl;
681
682 Release();
683 }
684 }
685
686 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Normalcase_05, TestSize.Level1)
687 {
688 bool result;
689 for (size_t i = 0; i < INPUT_AMRWB_FILE_SOURCE_PATH.size(); i++) {
690 cout << "decode start " << INPUT_AMRWB_FILE_SOURCE_PATH[i][0] << endl;
691 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_AMRWB_NAME, INPUT_AMRWB_FILE_SOURCE_PATH[i][0]));
692
693 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
694 stoi(INPUT_AMRWB_FILE_SOURCE_PATH[i][1]));
695 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
696 stoi(INPUT_AMRWB_FILE_SOURCE_PATH[i][2]));
697
698 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
699
700 isRunning_.store(true);
701 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
702 EXPECT_NE(nullptr, inputLoop_);
703 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
704 EXPECT_NE(nullptr, outputLoop_);
705
706 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
707 {
708 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50902() 709 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
710 }
711 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
712 result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
713 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_AMRWB_FILE_SOURCE_PATH[i][0] << endl;
714
715 Release();
716 }
717 }
718
719 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Normalcase_06, TestSize.Level1)
720 {
721 bool result;
722 for (size_t i = 0; i < INPUT_AMRNB_FILE_SOURCE_PATH.size(); i++) {
723 cout << "decode start " << INPUT_AMRNB_FILE_SOURCE_PATH[i][0] << endl;
724 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_AMRNB_NAME, INPUT_AMRNB_FILE_SOURCE_PATH[i][0]));
725
726 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
727 stoi(INPUT_AMRNB_FILE_SOURCE_PATH[i][1]));
728 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
729 stoi(INPUT_AMRNB_FILE_SOURCE_PATH[i][2]));
730
731 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
732
733 isRunning_.store(true);
734 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
735 EXPECT_NE(nullptr, inputLoop_);
736 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
737 EXPECT_NE(nullptr, outputLoop_);
738
739 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
740 {
741 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50a02() 742 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
743 }
744 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
745 result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
746 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_AMRNB_FILE_SOURCE_PATH[i][0] << endl;
747
748 Release();
749 }
750 }
751
752 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Normalcase_07, TestSize.Level1)
753 {
754 signal_ = nullptr;
755 if (!CheckSoFunc()) {
756 return;
757 }
758 bool result;
759 for (size_t i = 0; i < INPUT_OPUS_FILE_SOURCE_PATH.size(); i++) {
760 cout << "decode start " << INPUT_OPUS_FILE_SOURCE_PATH[i][0] << endl;
761 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_OPUS_NAME, INPUT_OPUS_FILE_SOURCE_PATH[i][0]));
762
763 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
764 stoi(INPUT_OPUS_FILE_SOURCE_PATH[i][1]));
765 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
766 stoi(INPUT_OPUS_FILE_SOURCE_PATH[i][2]));
767 EXPECT_NE(nullptr, signal_);
768 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
769
770 isRunning_.store(true);
771 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
772 EXPECT_NE(nullptr, inputLoop_);
773 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
774 EXPECT_NE(nullptr, outputLoop_);
775
776 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
777 {
778 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50b02() 779 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
780 }
781 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
782 result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
783 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_OPUS_FILE_SOURCE_PATH[i][0] << endl;
784
785 Release();
786 }
787 }
788
789 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Normalcase_08, TestSize.Level1)
790 {
791 bool result;
792 for (size_t i = 0; i < INPUT_G711MU_FILE_SOURCE_PATH.size(); i++) {
793 cout << "decode start " << INPUT_G711MU_FILE_SOURCE_PATH[i][0] << endl;
794 ASSERT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, InitFile(CODEC_G711MU_NAME, INPUT_G711MU_FILE_SOURCE_PATH[i][0]));
795
796 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(),
797 stoi(INPUT_G711MU_FILE_SOURCE_PATH[i][1]));
798 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(),
799 stoi(INPUT_G711MU_FILE_SOURCE_PATH[i][2]));
800
801 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
802
803 isRunning_.store(true);
804 inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
805 EXPECT_NE(nullptr, inputLoop_);
806 outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
807 EXPECT_NE(nullptr, outputLoop_);
808
809 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
810 {
811 unique_lock<mutex> lock(signal_->startMutex_);
__anon172020a50c02() 812 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
813 }
814 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
815 result = std::filesystem::file_size(OUTPUT_PCM_FILE_PATH) < 20;
816 EXPECT_EQ(result, false) << "error occur, decode fail" << INPUT_G711MU_FILE_SOURCE_PATH[i][0] << endl;
817
818 Release();
819 }
820 }
821 } // namespace MediaAVCodec
822 } // namespace OHOS
823