• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "avcodec_mime_type.h"
31 #include "media_description.h"
32 #include "native_avcodec_base.h"
33 #include "native_avformat.h"
34 #include "avcodec_common.h"
35 #include "avcodec_errors.h"
36 #include "native_avcodec_audiodecoder.h"
37 #include "securec.h"
38 
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::MediaAVCodec;
42 
43 namespace {
44 const string CODEC_MP3_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_MP3_NAME);
45 const string CODEC_FLAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_FLAC_NAME);
46 const string CODEC_AAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_AAC_NAME);
47 const string CODEC_VORBIS_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME);
48 constexpr uint32_t MAX_CHANNEL_COUNT = 2;
49 constexpr uint32_t ABNORMAL_MAX_CHANNEL_COUNT = 999999;
50 constexpr uint32_t ABNORMAL_MIN_CHANNEL_COUNT = 0;
51 constexpr uint32_t DEFAULT_SAMPLE_RATE = 44100;
52 constexpr uint32_t DEFAULT_MP3_BITRATE = 60000;
53 constexpr uint32_t DEFAULT_FLAC_BITRATE = 261000;
54 constexpr uint32_t DEFAULT_AAC_BITRATE = 199000;
55 constexpr uint32_t DEFAULT_VORBIS_BITRATE = 320000;
56 constexpr uint32_t ABNORMAL_MAX_INPUT_SIZE = 99999999;
57 constexpr uint32_t DEFAULT_AAC_TYPE = 1;
58 constexpr string_view INPUT_AAC_FILE_PATH = "/data/test/media/aac_2c_44100hz_199k.dat";
59 constexpr string_view OUTPUT_AAC_PCM_FILE_PATH = "/data/test/media/aac_2c_44100hz_199k.pcm";
60 constexpr string_view INPUT_FLAC_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.dat";
61 constexpr string_view OUTPUT_FLAC_PCM_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.pcm";
62 constexpr string_view INPUT_MP3_FILE_PATH = "/data/test/media/mp3_2c_44100hz_60k.dat";
63 constexpr string_view OUTPUT_MP3_PCM_FILE_PATH = "/data/test/media/mp3_2c_44100hz_60k.pcm";
64 constexpr string_view INPUT_VORBIS_FILE_PATH = "/data/test/media/vorbis_2c_44100hz_320k.dat";
65 constexpr string_view OUTPUT_VORBIS_PCM_FILE_PATH = "/data/test/media/vorbis_2c_44100hz_320k.pcm";
66 } // namespace
67 
68 namespace OHOS {
69 namespace MediaAVCodec {
70 class ADecSignal {
71 public:
72     std::mutex inMutex_;
73     std::mutex outMutex_;
74     std::mutex startMutex_;
75     std::condition_variable inCond_;
76     std::condition_variable outCond_;
77     std::condition_variable startCond_;
78     std::queue<uint32_t> inQueue_;
79     std::queue<uint32_t> outQueue_;
80     std::queue<OH_AVMemory *> inBufferQueue_;
81     std::queue<OH_AVMemory *> outBufferQueue_;
82     std::queue<OH_AVCodecBufferAttr> attrQueue_;
83 };
84 
OnError(OH_AVCodec * codec,int32_t errorCode,void * userData)85 static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData)
86 {
87     (void)codec;
88     (void)errorCode;
89     (void)userData;
90     cout << "Error received, errorCode:" << errorCode << endl;
91 }
92 
OnOutputFormatChanged(OH_AVCodec * codec,OH_AVFormat * format,void * userData)93 static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData)
94 {
95     (void)codec;
96     (void)format;
97     (void)userData;
98     cout << "OnOutputFormatChanged received" << endl;
99 }
100 
OnInputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,void * userData)101 static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, void *userData)
102 {
103     (void)codec;
104     ADecSignal *signal = static_cast<ADecSignal *>(userData);
105     unique_lock<mutex> lock(signal->inMutex_);
106     signal->inQueue_.push(index);
107     signal->inBufferQueue_.push(data);
108     signal->inCond_.notify_all();
109 }
110 
OnOutputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,OH_AVCodecBufferAttr * attr,void * userData)111 static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, OH_AVCodecBufferAttr *attr,
112                                     void *userData)
113 {
114     (void)codec;
115     ADecSignal *signal = static_cast<ADecSignal *>(userData);
116     unique_lock<mutex> lock(signal->outMutex_);
117     signal->outQueue_.push(index);
118     signal->outBufferQueue_.push(data);
119     if (attr) {
120         signal->attrQueue_.push(*attr);
121     } else {
122         cout << "OnOutputBufferAvailable error, attr is nullptr!" << endl;
123     }
124     signal->outCond_.notify_all();
125 }
126 
127 class AudioCodeCapiDecoderUnitTest : public testing::Test {
128 public:
129     static void SetUpTestCase(void);
130     static void TearDownTestCase(void);
131     void SetUp();
132     void TearDown();
133     int32_t InitFile(const string &codecName);
134     void InputFunc();
135     void OutputFunc();
136     int32_t CreateCodecFunc(const string &codecName);
137     void HandleInputEOS(const uint32_t index);
138     int32_t HandleNormalInput(const uint32_t &index, const int64_t pts, const size_t size);
139     int32_t Configure(const string &codecName);
140     int32_t Start();
141     int32_t Stop();
142     void Release();
143 
144 protected:
145     std::atomic<bool> isRunning_ = false;
146     std::unique_ptr<std::thread> inputLoop_;
147     std::unique_ptr<std::thread> outputLoop_;
148     struct OH_AVCodecAsyncCallback cb_;
149     ADecSignal *signal_ = nullptr;
150     OH_AVCodec *audioDec_ = nullptr;
151     ;
152     OH_AVFormat *format_ = nullptr;
153     ;
154     bool isFirstFrame_ = true;
155     std::ifstream inputFile_;
156     std::ofstream pcmOutputFile_;
157 };
158 
SetUpTestCase(void)159 void AudioCodeCapiDecoderUnitTest::SetUpTestCase(void)
160 {
161     cout << "[SetUpTestCase]: " << endl;
162 }
163 
TearDownTestCase(void)164 void AudioCodeCapiDecoderUnitTest::TearDownTestCase(void)
165 {
166     cout << "[TearDownTestCase]: " << endl;
167 }
168 
SetUp(void)169 void AudioCodeCapiDecoderUnitTest::SetUp(void)
170 {
171     cout << "[SetUp]: SetUp!!!" << endl;
172 }
173 
TearDown(void)174 void AudioCodeCapiDecoderUnitTest::TearDown(void)
175 {
176     cout << "[TearDown]: over!!!" << endl;
177 
178     if (signal_) {
179         delete signal_;
180         signal_ = nullptr;
181     }
182     if (inputFile_.is_open()) {
183         inputFile_.close();
184     }
185     if (pcmOutputFile_.is_open()) {
186         pcmOutputFile_.close();
187     }
188 }
189 
Release()190 void AudioCodeCapiDecoderUnitTest::Release()
191 {
192     Stop();
193     OH_AudioDecoder_Destroy(audioDec_);
194 }
195 
HandleInputEOS(const uint32_t index)196 void AudioCodeCapiDecoderUnitTest::HandleInputEOS(const uint32_t index)
197 {
198     OH_AVCodecBufferAttr info;
199     info.size = 0;
200     info.offset = 0;
201     info.pts = 0;
202     info.flags = AVCODEC_BUFFER_FLAGS_EOS;
203     OH_AudioDecoder_PushInputData(audioDec_, index, info);
204     signal_->inBufferQueue_.pop();
205     signal_->inQueue_.pop();
206 }
207 
HandleNormalInput(const uint32_t & index,const int64_t pts,const size_t size)208 int32_t AudioCodeCapiDecoderUnitTest::HandleNormalInput(const uint32_t &index, const int64_t pts, const size_t size)
209 {
210     OH_AVCodecBufferAttr info;
211     info.size = size;
212     info.offset = 0;
213     info.pts = pts;
214 
215     int32_t ret = OH_AVErrCode::AV_ERR_OK;
216     if (isFirstFrame_) {
217         info.flags = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
218         ret = OH_AudioDecoder_PushInputData(audioDec_, index, info);
219         EXPECT_EQ(AV_ERR_OK, ret);
220         isFirstFrame_ = false;
221     } else {
222         info.flags = AVCODEC_BUFFER_FLAGS_NONE;
223         ret = OH_AudioDecoder_PushInputData(audioDec_, index, info);
224         EXPECT_EQ(AV_ERR_OK, ret);
225     }
226     signal_->inQueue_.pop();
227     signal_->inBufferQueue_.pop();
228     return ret;
229 }
230 
InputFunc()231 void AudioCodeCapiDecoderUnitTest::InputFunc()
232 {
233     int64_t size;
234     int64_t pts;
235 
236     while (true) {
237         if (!isRunning_.load()) {
238             break;
239         }
240         unique_lock<mutex> lock(signal_->inMutex_);
241         signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
242 
243         if (!isRunning_.load()) {
244             break;
245         }
246 
247         uint32_t index = signal_->inQueue_.front();
248         auto buffer = signal_->inBufferQueue_.front();
249         if (buffer == nullptr) {
250             cout << "Fatal: GetInputBuffer fail" << endl;
251             break;
252         }
253         inputFile_.read(reinterpret_cast<char *>(&size), sizeof(size));
254         if (inputFile_.eof() || inputFile_.gcount() == 0) {
255             HandleInputEOS(index);
256             cout << "end buffer\n";
257             break;
258         }
259         if (inputFile_.gcount() != sizeof(size)) {
260             cout << "Fatal: read size fail" << endl;
261             break;
262         }
263         inputFile_.read(reinterpret_cast<char *>(&pts), sizeof(pts));
264         if (inputFile_.gcount() != sizeof(pts)) {
265             cout << "Fatal: read size fail" << endl;
266             break;
267         }
268         inputFile_.read((char *)OH_AVMemory_GetAddr(buffer), size);
269         if (inputFile_.gcount() != size) {
270             cout << "Fatal: read buffer fail" << endl;
271             break;
272         }
273 
274         int32_t ret = HandleNormalInput(index, pts, size);
275         if (ret != AV_ERR_OK) {
276             cout << "Fatal error, exit" << endl;
277             break;
278         }
279     }
280     inputFile_.close();
281 }
282 
OutputFunc()283 void AudioCodeCapiDecoderUnitTest::OutputFunc()
284 {
285     if (!pcmOutputFile_.is_open()) {
286         std::cout << "open " << OUTPUT_MP3_PCM_FILE_PATH << " failed!" << std::endl;
287     }
288     while (true) {
289         if (!isRunning_.load()) {
290             cout << "stop, exit" << endl;
291             break;
292         }
293 
294         unique_lock<mutex> lock(signal_->outMutex_);
295         signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
296 
297         if (!isRunning_.load()) {
298             cout << "wait to stop, exit" << endl;
299             break;
300         }
301 
302         uint32_t index = signal_->outQueue_.front();
303         OH_AVCodecBufferAttr attr = signal_->attrQueue_.front();
304         OH_AVMemory *data = signal_->outBufferQueue_.front();
305         if (data != nullptr) {
306             pcmOutputFile_.write(reinterpret_cast<char *>(OH_AVMemory_GetAddr(data)), attr.size);
307         }
308 
309         if (attr.flags == AVCODEC_BUFFER_FLAGS_EOS) {
310             cout << "decode eos" << endl;
311             isRunning_.store(false);
312         }
313         signal_->outBufferQueue_.pop();
314         signal_->attrQueue_.pop();
315         signal_->outQueue_.pop();
316         EXPECT_EQ(AV_ERR_OK, OH_AudioDecoder_FreeOutputData(audioDec_, index));
317     }
318 
319     pcmOutputFile_.close();
320     signal_->startCond_.notify_all();
321 }
322 
Start()323 int32_t AudioCodeCapiDecoderUnitTest::Start()
324 {
325     isRunning_.store(true);
326     inputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::InputFunc, this);
327     if (inputLoop_ == nullptr) {
328         cout << "Fatal: No memory" << endl;
329         return OH_AVErrCode::AV_ERR_UNKNOWN;
330     }
331 
332     outputLoop_ = make_unique<thread>(&AudioCodeCapiDecoderUnitTest::OutputFunc, this);
333     if (outputLoop_ == nullptr) {
334         cout << "Fatal: No memory" << endl;
335         return OH_AVErrCode::AV_ERR_UNKNOWN;
336     }
337 
338     return OH_AudioDecoder_Start(audioDec_);
339 }
340 
Stop()341 int32_t AudioCodeCapiDecoderUnitTest::Stop()
342 {
343     isRunning_.store(false);
344     if (!signal_) {
345         return OH_AVErrCode::AV_ERR_UNKNOWN;
346     }
347     signal_->startCond_.notify_all();
348     if (inputLoop_ != nullptr && inputLoop_->joinable()) {
349         {
350             unique_lock<mutex> lock(signal_->inMutex_);
351             signal_->inCond_.notify_all();
352         }
353         inputLoop_->join();
354     }
355 
356     if (outputLoop_ != nullptr && outputLoop_->joinable()) {
357         {
358             unique_lock<mutex> lock(signal_->outMutex_);
359             signal_->outCond_.notify_all();
360         }
361         outputLoop_->join();
362     }
363     return OH_AudioDecoder_Stop(audioDec_);
364 }
365 
InitFile(const string & codecName)366 int32_t AudioCodeCapiDecoderUnitTest::InitFile(const string &codecName)
367 {
368     if (codecName.compare(CODEC_MP3_NAME) == 0) {
369         inputFile_.open(INPUT_MP3_FILE_PATH.data(), std::ios::binary);
370         pcmOutputFile_.open(OUTPUT_MP3_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary);
371     } else if (codecName.compare(CODEC_FLAC_NAME) == 0) {
372         inputFile_.open(INPUT_FLAC_FILE_PATH.data(), std::ios::binary);
373         pcmOutputFile_.open(OUTPUT_FLAC_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary);
374     } else if (codecName.compare(CODEC_AAC_NAME) == 0) {
375         inputFile_.open(INPUT_AAC_FILE_PATH.data(), std::ios::binary);
376         pcmOutputFile_.open(OUTPUT_AAC_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary);
377     } else if (codecName.compare(CODEC_VORBIS_NAME) == 0) {
378         inputFile_.open(INPUT_VORBIS_FILE_PATH.data(), std::ios::binary);
379         pcmOutputFile_.open(OUTPUT_VORBIS_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary);
380     } else {
381         cout << "Fatal: audio format type not support" << endl;
382         return OH_AVErrCode::AV_ERR_UNKNOWN;
383     }
384 
385     if (!inputFile_.is_open()) {
386         cout << "Fatal: open input file failed" << endl;
387         return OH_AVErrCode::AV_ERR_UNKNOWN;
388     }
389     if (!pcmOutputFile_.is_open()) {
390         cout << "Fatal: open output file failed" << endl;
391         return OH_AVErrCode::AV_ERR_UNKNOWN;
392     }
393     return OH_AVErrCode::AV_ERR_OK;
394 }
395 
CreateCodecFunc(const string & codecName)396 int32_t AudioCodeCapiDecoderUnitTest::CreateCodecFunc(const string &codecName)
397 {
398     if (codecName.compare(CODEC_MP3_NAME) == 0) {
399         audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_MP3_NAME).data());
400     } else if (codecName.compare(CODEC_FLAC_NAME) == 0) {
401         audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_FLAC_NAME).data());
402     } else if (codecName.compare(CODEC_AAC_NAME) == 0) {
403         audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_AAC_NAME).data());
404     } else if (codecName.compare(CODEC_VORBIS_NAME) == 0) {
405         audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME).data());
406     } else {
407         cout << "audio name not support" << endl;
408         return OH_AVErrCode::AV_ERR_UNKNOWN;
409     }
410 
411     if (audioDec_ == nullptr) {
412         cout << "Fatal: CreateByName fail" << endl;
413         return OH_AVErrCode::AV_ERR_UNKNOWN;
414     }
415 
416     signal_ = new ADecSignal();
417     if (signal_ == nullptr) {
418         cout << "Fatal: create signal fail" << endl;
419         return OH_AVErrCode::AV_ERR_UNKNOWN;
420     }
421     cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
422     int32_t ret = OH_AudioDecoder_SetCallback(audioDec_, cb_, signal_);
423     if (ret != OH_AVErrCode::AV_ERR_OK) {
424         cout << "Fatal: SetCallback fail" << endl;
425         return OH_AVErrCode::AV_ERR_UNKNOWN;
426     }
427 
428     return OH_AVErrCode::AV_ERR_OK;
429 }
430 
Configure(const string & codecName)431 int32_t AudioCodeCapiDecoderUnitTest::Configure(const string &codecName)
432 {
433     format_ = OH_AVFormat_Create();
434     if (format_ == nullptr) {
435         cout << "Fatal: create format failed" << endl;
436         return OH_AVErrCode::AV_ERR_UNKNOWN;
437     }
438 
439     uint32_t bitRate = DEFAULT_MP3_BITRATE;
440     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
441     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
442     if (codecName.compare(CODEC_FLAC_NAME) == 0) {
443         bitRate = DEFAULT_FLAC_BITRATE;
444     }
445     if (codecName.compare(CODEC_AAC_NAME) == 0) {
446         bitRate = DEFAULT_AAC_BITRATE;
447         OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AAC_IS_ADTS.data(), DEFAULT_AAC_TYPE);
448     }
449     if (codecName.compare(CODEC_VORBIS_NAME) == 0) {
450         bitRate = DEFAULT_VORBIS_BITRATE;
451         if (!inputFile_.is_open()) {
452             cout << "Fatal: open input file failed" << endl;
453             return OH_AVErrCode::AV_ERR_UNKNOWN;
454         }
455         int64_t extradataSize = 0;
456         inputFile_.read(reinterpret_cast<char *>(&extradataSize), sizeof(int64_t));
457         if (inputFile_.gcount() != sizeof(int64_t) || extradataSize < 0) {
458             cout << "Fatal: read extradataSize bytes error" << endl;
459             return OH_AVErrCode::AV_ERR_UNKNOWN;
460         }
461         char buffer[extradataSize];
462         inputFile_.read(buffer, extradataSize);
463         if (inputFile_.gcount() != extradataSize) {
464             cout << "Fatal: read extradata bytes error" << endl;
465             return OH_AVErrCode::AV_ERR_UNKNOWN;
466         }
467         OH_AVFormat_SetBuffer(format_, MediaDescriptionKey::MD_KEY_CODEC_CONFIG.data(), (uint8_t *)buffer,
468                               extradataSize);
469     }
470     OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(), bitRate);
471 
472     return OH_AudioDecoder_Configure(audioDec_, format_);
473 }
474 
475 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_CreateByMime_01, TestSize.Level1)
476 {
477     audioDec_ = OH_AudioDecoder_CreateByMime(AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG.data());
478     EXPECT_NE(nullptr, audioDec_);
479     Release();
480 }
481 
482 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_CreateByName_01, TestSize.Level1)
483 {
484     audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_MP3_NAME).data());
485     EXPECT_NE(nullptr, audioDec_);
486     Release();
487 }
488 
489 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Configure_01, TestSize.Level1)
490 {
491     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
492     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
493     Release();
494 }
495 
496 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_SetParameter_01, TestSize.Level1)
497 {
498     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
499     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
500     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
501     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
502     {
503         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0402() 504         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
505     }
506     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Flush(audioDec_));
507     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_SetParameter(audioDec_, format_));
508     Release();
509 }
510 
511 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_SetParameter_02, TestSize.Level1)
512 {
513     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
514     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
515     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_SetParameter(audioDec_, format_));
516     Release();
517 }
518 
519 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Start_01, TestSize.Level1)
520 {
521     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
522     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
523     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
524     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
525     {
526         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0502() 527         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
528     }
529     Release();
530 }
531 
532 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Start_02, TestSize.Level1)
533 {
534     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
535     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
536     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
537     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
538     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
539     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
540     {
541         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0602() 542         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
543     }
544     Release();
545 }
546 
547 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Stop_01, TestSize.Level1)
548 {
549     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
550     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
551     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
552     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
553     sleep(1);
554 
555     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
556     Release();
557 }
558 
559 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Flush_01, TestSize.Level1)
560 {
561     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
562     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
563     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
564     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
565     {
566         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0702() 567         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
568     }
569     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Flush(audioDec_));
570     Release();
571 }
572 
573 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Reset_01, TestSize.Level1)
574 {
575     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
576     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
577     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
578     Release();
579 }
580 
581 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Reset_02, TestSize.Level1)
582 {
583     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
584     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
585     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
586     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
587     {
588         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0802() 589         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
590     }
591     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
592     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
593     Release();
594 }
595 
596 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Reset_03, TestSize.Level1)
597 {
598     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
599     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
600     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
601     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
602     {
603         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0902() 604         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
605     }
606     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
607     Release();
608 }
609 
610 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Destroy_01, TestSize.Level1)
611 {
612     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
613     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
614     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
615     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
616     {
617         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0a02() 618         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
619     }
620     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
621     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Destroy(audioDec_));
622 }
623 
624 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Destroy_02, TestSize.Level1)
625 {
626     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
627     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
628     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
629 
630     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Destroy(audioDec_));
631 }
632 
633 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_GetOutputFormat_01, TestSize.Level1)
634 {
635     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
636     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
637     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
638 
639     EXPECT_NE(nullptr, OH_AudioDecoder_GetOutputDescription(audioDec_));
640     Release();
641 }
642 
643 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_IsValid_01, TestSize.Level1)
644 {
645     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
646     bool isValid = false;
647     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_IsValid(audioDec_, &isValid));
648     Release();
649 }
650 
651 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_Prepare_01, TestSize.Level1)
652 {
653     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
654     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Prepare(audioDec_));
655     Release();
656 }
657 
658 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_PushInputData_01, TestSize.Level1)
659 {
660     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
661     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
662     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
663     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
664 
665     // case0 传参异常
666     uint32_t index = 0;
667     OH_AVCodecBufferAttr attr;
668     attr.pts = 0;
669     attr.size = -1;
670     attr.offset = 0;
671     attr.flags = AVCODEC_BUFFER_FLAG_EOS;
672     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_PushInputData(audioDec_, index, attr));
673     Release();
674 }
675 
676 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Mp3_ReleaseOutputBuffer_01, TestSize.Level1)
677 {
678     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_MP3_NAME));
679     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_MP3_NAME));
680     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_MP3_NAME));
681     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
682 
683     // case0 传参异常
684     uint32_t index = 1024;
685     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_FreeOutputData(audioDec_, index));
686     Release();
687 }
688 
689 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_CreateByMime_01, TestSize.Level1)
690 {
691     audioDec_ = OH_AudioDecoder_CreateByMime(AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC.data());
692     EXPECT_NE(nullptr, audioDec_);
693     Release();
694 }
695 
696 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_CreateByName_01, TestSize.Level1)
697 {
698     audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_FLAC_NAME).data());
699     EXPECT_NE(nullptr, audioDec_);
700     Release();
701 }
702 
703 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Configure_01, TestSize.Level1)
704 {
705     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
706     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
707     Release();
708 }
709 
710 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Configure_02, TestSize.Level1)
711 {
712     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
713     format_ = OH_AVFormat_Create();
714     EXPECT_NE(nullptr, format_);
715     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ABNORMAL_MIN_CHANNEL_COUNT);
716     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
717     OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(), DEFAULT_FLAC_BITRATE);
718     ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
719     Release();
720 }
721 
722 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Configure_03, TestSize.Level1)
723 {
724     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
725     format_ = OH_AVFormat_Create();
726     EXPECT_NE(nullptr, format_);
727     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ABNORMAL_MAX_CHANNEL_COUNT);
728     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
729     OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(), DEFAULT_FLAC_BITRATE);
730     ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
731     Release();
732 }
733 
734 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_SetParameter_01, TestSize.Level1)
735 {
736     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
737     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
738     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
739     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
740     {
741         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0b02() 742         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
743     }
744     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Flush(audioDec_));
745     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_SetParameter(audioDec_, format_));
746     Release();
747 }
748 
749 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_SetParameter_02, TestSize.Level1)
750 {
751     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
752     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
753     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_SetParameter(audioDec_, format_));
754     Release();
755 }
756 
757 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Start_01, TestSize.Level1)
758 {
759     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
760     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
761     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
762     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
763     {
764         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0c02() 765         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
766     }
767     Release();
768 }
769 
770 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Start_02, TestSize.Level1)
771 {
772     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
773     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
774     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
775     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
776     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
777     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
778     {
779         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0d02() 780         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
781     }
782     Release();
783 }
784 
785 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Start_03, TestSize.Level1)
786 {
787     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
788     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
789     format_ = OH_AVFormat_Create();
790     EXPECT_NE(nullptr, format_);
791     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
792     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
793     OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(), DEFAULT_FLAC_BITRATE);
794     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), ABNORMAL_MAX_INPUT_SIZE);
795     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
796 
797     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
798     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
799     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
800     {
801         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0e02() 802         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
803     }
804     Release();
805 }
806 
807 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Stop_01, TestSize.Level1)
808 {
809     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
810     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
811     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
812     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
813     sleep(1);
814 
815     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
816     Release();
817 }
818 
819 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Flush_01, TestSize.Level1)
820 {
821     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
822     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
823     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
824     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
825     {
826         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b0f02() 827         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
828     }
829     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Flush(audioDec_));
830     Release();
831 }
832 
833 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Reset_01, TestSize.Level1)
834 {
835     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
836     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
837     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
838     Release();
839 }
840 
841 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Reset_02, TestSize.Level1)
842 {
843     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
844     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
845     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
846     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
847     {
848         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1002() 849         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
850     }
851     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
852     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
853     Release();
854 }
855 
856 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Reset_03, TestSize.Level1)
857 {
858     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
859     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
860     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
861     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
862     {
863         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1102() 864         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
865     }
866     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
867     Release();
868 }
869 
870 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Destroy_01, TestSize.Level1)
871 {
872     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
873     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
874     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
875     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
876     {
877         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1202() 878         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
879     }
880     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
881     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Destroy(audioDec_));
882 }
883 
884 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Destroy_02, TestSize.Level1)
885 {
886     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
887     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
888     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
889 
890     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Destroy(audioDec_));
891 }
892 
893 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_GetOutputFormat_01, TestSize.Level1)
894 {
895     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
896     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
897     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
898 
899     EXPECT_NE(nullptr, OH_AudioDecoder_GetOutputDescription(audioDec_));
900     Release();
901 }
902 
903 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_IsValid_01, TestSize.Level1)
904 {
905     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
906     bool isValid = false;
907     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_IsValid(audioDec_, &isValid));
908     Release();
909 }
910 
911 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_Prepare_01, TestSize.Level1)
912 {
913     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
914     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Prepare(audioDec_));
915     Release();
916 }
917 
918 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_PushInputData_01, TestSize.Level1)
919 {
920     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
921     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
922     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
923     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
924 
925     // case0 传参异常
926     uint32_t index = 0;
927     OH_AVCodecBufferAttr attr;
928     attr.pts = 0;
929     attr.size = -1;
930     attr.offset = 0;
931     attr.flags = AVCODEC_BUFFER_FLAG_EOS;
932     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_PushInputData(audioDec_, index, attr));
933     Release();
934 }
935 
936 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Flac_ReleaseOutputBuffer_01, TestSize.Level1)
937 {
938     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_FLAC_NAME));
939     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_FLAC_NAME));
940     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_FLAC_NAME));
941     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
942 
943     // case0 传参异常
944     uint32_t index = 1024;
945     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_FreeOutputData(audioDec_, index));
946     Release();
947 }
948 
949 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_CreateByMime_01, TestSize.Level1)
950 {
951     audioDec_ = OH_AudioDecoder_CreateByMime(AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC.data());
952     EXPECT_NE(nullptr, audioDec_);
953     Release();
954 }
955 
956 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_CreateByName_01, TestSize.Level1)
957 {
958     audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_AAC_NAME).data());
959     EXPECT_NE(nullptr, audioDec_);
960     Release();
961 }
962 
963 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Configure_01, TestSize.Level1)
964 {
965     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
966     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
967     Release();
968 }
969 
970 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Configure_02, TestSize.Level1)
971 {
972     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
973     format_ = OH_AVFormat_Create();
974     EXPECT_NE(nullptr, format_);
975     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ABNORMAL_MIN_CHANNEL_COUNT);
976     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
977     OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(), DEFAULT_AAC_BITRATE);
978     ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
979     Release();
980 }
981 
982 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Configure_03, TestSize.Level1)
983 {
984     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
985     format_ = OH_AVFormat_Create();
986     EXPECT_NE(nullptr, format_);
987     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ABNORMAL_MAX_CHANNEL_COUNT);
988     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
989     OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(), DEFAULT_AAC_BITRATE);
990     ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
991     Release();
992 }
993 
994 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_SetParameter_01, TestSize.Level1)
995 {
996     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
997     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
998     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
999     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1000     {
1001         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1302() 1002         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1003     }
1004     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Flush(audioDec_));
1005     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_SetParameter(audioDec_, format_));
1006     Release();
1007 }
1008 
1009 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_SetParameter_02, TestSize.Level1)
1010 {
1011     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1012     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1013     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_SetParameter(audioDec_, format_));
1014     Release();
1015 }
1016 
1017 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Start_01, TestSize.Level1)
1018 {
1019     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1020     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1021     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1022     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1023     {
1024         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1402() 1025         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1026     }
1027     Release();
1028 }
1029 
1030 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Start_02, TestSize.Level1)
1031 {
1032     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1033     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1034     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1035     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1036     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1037     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
1038     {
1039         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1502() 1040         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1041     }
1042     Release();
1043 }
1044 
1045 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Start_03, TestSize.Level1)
1046 {
1047     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1048     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1049     format_ = OH_AVFormat_Create();
1050     EXPECT_NE(nullptr, format_);
1051     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
1052     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
1053     OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(), DEFAULT_AAC_BITRATE);
1054     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), ABNORMAL_MAX_INPUT_SIZE);
1055     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Configure(audioDec_, format_));
1056 
1057     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1058     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1059     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
1060     {
1061         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1602() 1062         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1063     }
1064     Release();
1065 }
1066 
1067 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Stop_01, TestSize.Level1)
1068 {
1069     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1070     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1071     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1072     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1073     sleep(1);
1074 
1075     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1076     Release();
1077 }
1078 
1079 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Flush_01, TestSize.Level1)
1080 {
1081     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1082     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1083     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1084     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1085     {
1086         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1702() 1087         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1088     }
1089     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Flush(audioDec_));
1090     Release();
1091 }
1092 
1093 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Reset_01, TestSize.Level1)
1094 {
1095     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1096     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1097     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
1098     Release();
1099 }
1100 
1101 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Reset_02, TestSize.Level1)
1102 {
1103     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1104     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1105     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1106     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1107     {
1108         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1802() 1109         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1110     }
1111     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1112     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
1113     Release();
1114 }
1115 
1116 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Reset_03, TestSize.Level1)
1117 {
1118     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1119     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1120     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1121     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1122     {
1123         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1902() 1124         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1125     }
1126     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
1127     Release();
1128 }
1129 
1130 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Destroy_01, TestSize.Level1)
1131 {
1132     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1133     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1134     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1135     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1136     {
1137         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1a02() 1138         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1139     }
1140     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1141     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Destroy(audioDec_));
1142 }
1143 
1144 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Destroy_02, TestSize.Level1)
1145 {
1146     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1147     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1148     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1149 
1150     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Destroy(audioDec_));
1151 }
1152 
1153 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_GetOutputFormat_01, TestSize.Level1)
1154 {
1155     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1156     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1157     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1158 
1159     EXPECT_NE(nullptr, OH_AudioDecoder_GetOutputDescription(audioDec_));
1160     Release();
1161 }
1162 
1163 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_IsValid_01, TestSize.Level1)
1164 {
1165     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1166     bool isValid = false;
1167     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_IsValid(audioDec_, &isValid));
1168     Release();
1169 }
1170 
1171 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_Prepare_01, TestSize.Level1)
1172 {
1173     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1174     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Prepare(audioDec_));
1175     Release();
1176 }
1177 
1178 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_PushInputData_01, TestSize.Level1)
1179 {
1180     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1181     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1182     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1183     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1184 
1185     // case0 传参异常
1186     uint32_t index = 0;
1187     OH_AVCodecBufferAttr attr;
1188     attr.pts = 0;
1189     attr.size = -1;
1190     attr.offset = 0;
1191     attr.flags = AVCODEC_BUFFER_FLAG_EOS;
1192     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_PushInputData(audioDec_, index, attr));
1193     Release();
1194 }
1195 
1196 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Aac_ReleaseOutputBuffer_01, TestSize.Level1)
1197 {
1198     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_AAC_NAME));
1199     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_AAC_NAME));
1200     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_AAC_NAME));
1201     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1202 
1203     // case0 传参异常
1204     uint32_t index = 1024;
1205     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_FreeOutputData(audioDec_, index));
1206     Release();
1207 }
1208 
1209 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_CreateByMime_01, TestSize.Level1)
1210 {
1211     audioDec_ = OH_AudioDecoder_CreateByMime(AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VORBIS.data());
1212     EXPECT_NE(nullptr, audioDec_);
1213     Release();
1214 }
1215 
1216 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_CreateByName_01, TestSize.Level1)
1217 {
1218     audioDec_ = OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME).data());
1219     EXPECT_NE(nullptr, audioDec_);
1220     Release();
1221 }
1222 
1223 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Configure_01, TestSize.Level1)
1224 {
1225     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1226     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1227     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1228     Release();
1229 }
1230 
1231 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_SetParameter_01, TestSize.Level1)
1232 {
1233     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1234     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1235     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1236     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1237     {
1238         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1b02() 1239         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1240     }
1241     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Flush(audioDec_));
1242     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_SetParameter(audioDec_, format_));
1243     Release();
1244 }
1245 
1246 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_SetParameter_02, TestSize.Level1)
1247 {
1248     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1249     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1250     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1251     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_SetParameter(audioDec_, format_));
1252     Release();
1253 }
1254 
1255 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Start_01, TestSize.Level1)
1256 {
1257     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1258     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1259     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1260     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1261     {
1262         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1c02() 1263         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1264     }
1265     Release();
1266 }
1267 
1268 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Start_02, TestSize.Level1)
1269 {
1270     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1271     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1272     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1273     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1274     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1275     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Start(audioDec_));
1276     {
1277         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1d02() 1278         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1279     }
1280     Release();
1281 }
1282 
1283 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Stop_01, TestSize.Level1)
1284 {
1285     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1286     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1287     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1288     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1289     sleep(1);
1290 
1291     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1292     Release();
1293 }
1294 
1295 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Flush_01, TestSize.Level1)
1296 {
1297     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1298     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1299     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1300     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1301     {
1302         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1e02() 1303         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1304     }
1305     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Flush(audioDec_));
1306     Release();
1307 }
1308 
1309 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Reset_01, TestSize.Level1)
1310 {
1311     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1312     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1313     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1314     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
1315     Release();
1316 }
1317 
1318 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Reset_02, TestSize.Level1)
1319 {
1320     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1321     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1322     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1323     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1324     {
1325         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b1f02() 1326         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1327     }
1328     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1329     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
1330     Release();
1331 }
1332 
1333 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Reset_03, TestSize.Level1)
1334 {
1335     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1336     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1337     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1338     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1339     {
1340         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b2002() 1341         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1342     }
1343     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Reset(audioDec_));
1344     Release();
1345 }
1346 
1347 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Destroy_01, TestSize.Level1)
1348 {
1349     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1350     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1351     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1352     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1353     {
1354         unique_lock<mutex> lock(signal_->startMutex_);
__anon9b8aa55b2102() 1355         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1356     }
1357     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1358     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Destroy(audioDec_));
1359 }
1360 
1361 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Destroy_02, TestSize.Level1)
1362 {
1363     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1364     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1365     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1366 
1367     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Destroy(audioDec_));
1368 }
1369 
1370 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_GetOutputFormat_01, TestSize.Level1)
1371 {
1372     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1373     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1374     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1375 
1376     EXPECT_NE(nullptr, OH_AudioDecoder_GetOutputDescription(audioDec_));
1377     Release();
1378 }
1379 
1380 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_IsValid_01, TestSize.Level1)
1381 {
1382     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1383     bool isValid = false;
1384     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_IsValid(audioDec_, &isValid));
1385     Release();
1386 }
1387 
1388 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_Prepare_01, TestSize.Level1)
1389 {
1390     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1391     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_Prepare(audioDec_));
1392     Release();
1393 }
1394 
1395 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_PushInputData_01, TestSize.Level1)
1396 {
1397     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1398     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1399     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1400     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1401 
1402     // case0 传参异常
1403     uint32_t index = 0;
1404     OH_AVCodecBufferAttr attr;
1405     attr.pts = 0;
1406     attr.size = -1;
1407     attr.offset = 0;
1408     attr.flags = AVCODEC_BUFFER_FLAG_EOS;
1409     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_PushInputData(audioDec_, index, attr));
1410     Release();
1411 }
1412 
1413 HWTEST_F(AudioCodeCapiDecoderUnitTest, audioDecoder_Vorbis_ReleaseOutputBuffer_01, TestSize.Level1)
1414 {
1415     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VORBIS_NAME));
1416     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1417     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure(CODEC_VORBIS_NAME));
1418     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1419 
1420     // case0 传参异常
1421     uint32_t index = 1024;
1422     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioDecoder_FreeOutputData(audioDec_, index));
1423     Release();
1424 }
1425 
1426 HWTEST_F(AudioCodeCapiDecoderUnitTest, vorbisMissingHeader, TestSize.Level1)
1427 {
1428     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1429     format_ = OH_AVFormat_Create();
1430     EXPECT_NE(nullptr, format_);
1431     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
1432     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
1433     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), ABNORMAL_MAX_INPUT_SIZE);
1434     EXPECT_EQ(OH_AVErrCode::AV_ERR_INVALID_VAL, OH_AudioDecoder_Configure(audioDec_, format_));
1435     Release();
1436 }
1437 
1438 HWTEST_F(AudioCodeCapiDecoderUnitTest, vorbisMissingIdHeader, TestSize.Level1)
1439 {
1440     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1441     format_ = OH_AVFormat_Create();
1442     EXPECT_NE(nullptr, format_);
1443     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
1444     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
1445     uint8_t buffer[1];
1446     OH_AVFormat_SetBuffer(format_, MediaDescriptionKey::MD_KEY_IDENTIFICATION_HEADER.data(), buffer, 1);
1447     EXPECT_EQ(OH_AVErrCode::AV_ERR_INVALID_VAL, OH_AudioDecoder_Configure(audioDec_, format_));
1448     Release();
1449 }
1450 
1451 HWTEST_F(AudioCodeCapiDecoderUnitTest, vorbisInvalidHeader, TestSize.Level1)
1452 {
1453     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VORBIS_NAME));
1454     format_ = OH_AVFormat_Create();
1455     EXPECT_NE(nullptr, format_);
1456     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
1457     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
1458     uint8_t buffer[1];
1459     OH_AVFormat_SetBuffer(format_, MediaDescriptionKey::MD_KEY_IDENTIFICATION_HEADER.data(), buffer, 1);
1460     OH_AVFormat_SetBuffer(format_, MediaDescriptionKey::MD_KEY_SETUP_HEADER.data(), buffer, 1);
1461     EXPECT_EQ(OH_AVErrCode::AV_ERR_UNKNOWN, OH_AudioDecoder_Configure(audioDec_, format_));
1462     Release();
1463 }
1464 
1465 HWTEST_F(AudioCodeCapiDecoderUnitTest, invalidDecoderNames, TestSize.Level1)
1466 {
1467     EXPECT_EQ(OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_ENCODER_FLAC_NAME).data()), nullptr);
1468     EXPECT_EQ(OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_ENCODER_AAC_NAME).data()), nullptr);
1469     EXPECT_EQ(OH_AudioDecoder_CreateByName((AVCodecCodecName::AUDIO_ENCODER_API9_AAC_NAME).data()), nullptr);
1470 }
1471 } // namespace MediaAVCodec
1472 } // namespace OHOS