1 /*
2  * Copyright (C) 2024 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 #include <atomic>
16 #include <chrono>
17 #include <fstream>
18 #include <gtest/gtest.h>
19 #include <iostream>
20 #include <queue>
21 #include <string>
22 #include <thread>
23 #include <unistd.h>
24 
25 #include "avcodec_codec_name.h"
26 #include "avcodec_mime_type.h"
27 #include "common/native_mfmagic.h"
28 #include "media_description.h"
29 #include "native_avbuffer.h"
30 #include "native_avcodec_audiocodec.h"
31 
32 using namespace std;
33 using namespace testing::ext;
34 using namespace OHOS::MediaAVCodec;
35 namespace {
36 const string CODEC_VIVID_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_VIVID_NAME);
37 constexpr uint32_t VIVID_MIN_CHANNEL_COUNT = 0;
38 constexpr uint32_t VIVID_MAX_CHANNEL_COUNT = 17;
39 constexpr uint32_t MAX_CHANNEL_COUNT = 2;
40 constexpr uint32_t DEFAULT_SAMPLE_RATE = 48000;
41 constexpr uint32_t VIVID_MAX_INPUT_SIZE = 99999999;
42 constexpr string_view INPUT_VIVID_FILE_PATH = "/data/test/media/vivid_2c_44100hz_320k.dat";
43 constexpr string_view OUTPUT_VIVID_PCM_FILE_PATH = "/data/test/media/vivid_2c_44100hz_320k.pcm";
44 } // namespace
45 
46 namespace OHOS {
47 namespace MediaAVCodec {
48 class ADecBufferSignal {
49 public:
50     std::mutex inMutex_;
51     std::mutex outMutex_;
52     std::mutex startMutex_;
53     std::condition_variable inCond_;
54     std::condition_variable outCond_;
55     std::condition_variable startCond_;
56     std::queue<uint32_t> inQueue_;
57     std::queue<uint32_t> outQueue_;
58     std::queue<OH_AVBuffer *> inBufferQueue_;
59     std::queue<OH_AVBuffer *> outBufferQueue_;
60 };
61 
OnError(OH_AVCodec * codec,int32_t errorCode,void * userData)62 static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData)
63 {
64     (void)codec;
65     (void)errorCode;
66     (void)userData;
67     cout << "Error received, errorCode:" << errorCode << endl;
68 }
69 
OnOutputFormatChanged(OH_AVCodec * codec,OH_AVFormat * format,void * userData)70 static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData)
71 {
72     (void)codec;
73     (void)format;
74     (void)userData;
75     cout << "OnOutputFormatChanged received" << endl;
76 }
77 
OnInputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * data,void * userData)78 static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData)
79 {
80     (void)codec;
81     ADecBufferSignal *signal = static_cast<ADecBufferSignal *>(userData);
82     unique_lock<mutex> lock(signal->inMutex_);
83     signal->inQueue_.push(index);
84     signal->inBufferQueue_.push(data);
85     signal->inCond_.notify_all();
86 }
87 
OnOutputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * data,void * userData)88 static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData)
89 {
90     (void)codec;
91     ADecBufferSignal *signal = static_cast<ADecBufferSignal *>(userData);
92     unique_lock<mutex> lock(signal->outMutex_);
93     signal->outQueue_.push(index);
94     signal->outBufferQueue_.push(data);
95     signal->outCond_.notify_all();
96 }
97 
98 class AudioVividCodeCapiDecoderUnitTest : public testing::Test {
99 public:
100     static void SetUpTestCase(void);
101     static void TearDownTestCase(void);
102     void SetUp();
103     void TearDown();
104     int32_t InitFile(const string &codecName);
105     void InputFunc();
106     void OutputFunc();
107     int32_t CreateCodecFunc(const string &codecName);
108     int32_t HandleInputBuffer(const uint32_t index);
109     int32_t Configure();
110     int32_t Configure24Bit();
111     int32_t Start();
112     int32_t Stop();
113     void Release();
114 
115 protected:
116     std::atomic<bool> isRunning_ = false;
117     std::unique_ptr<std::thread> inputLoop_;
118     std::unique_ptr<std::thread> outputLoop_;
119     struct OH_AVCodecCallback cb_;
120     ADecBufferSignal *signal_ = nullptr;
121     OH_AVCodec *audioDec_ = nullptr;
122     OH_AVFormat *format_ = nullptr;
123     bool isFirstFrame_ = true;
124     std::ifstream inputFile_;
125     std::ofstream pcmOutputFile_;
126 };
127 
SetUpTestCase(void)128 void AudioVividCodeCapiDecoderUnitTest::SetUpTestCase(void)
129 {
130     cout << "[SetUpTestCase]: " << endl;
131 }
132 
TearDownTestCase(void)133 void AudioVividCodeCapiDecoderUnitTest::TearDownTestCase(void)
134 {
135     cout << "[TearDownTestCase]: " << endl;
136 }
137 
SetUp(void)138 void AudioVividCodeCapiDecoderUnitTest::SetUp(void)
139 {
140     cout << "[SetUp]: SetUp!!!" << endl;
141 }
142 
TearDown(void)143 void AudioVividCodeCapiDecoderUnitTest::TearDown(void)
144 {
145     cout << "[TearDown]: over!!!" << endl;
146 
147     if (signal_) {
148         delete signal_;
149         signal_ = nullptr;
150     }
151     if (inputFile_.is_open()) {
152         inputFile_.close();
153     }
154     if (pcmOutputFile_.is_open()) {
155         pcmOutputFile_.close();
156     }
157 }
158 
Release()159 void AudioVividCodeCapiDecoderUnitTest::Release()
160 {
161     Stop();
162     OH_AudioCodec_Destroy(audioDec_);
163 }
164 
HandleInputBuffer(const uint32_t index)165 int32_t AudioVividCodeCapiDecoderUnitTest::HandleInputBuffer(const uint32_t index)
166 {
167     int32_t ret = OH_AudioCodec_PushInputBuffer(audioDec_, index);
168     signal_->inBufferQueue_.pop();
169     signal_->inQueue_.pop();
170     return ret;
171 }
172 
InputFunc()173 void AudioVividCodeCapiDecoderUnitTest::InputFunc()
174 {
175     int64_t size;
176     while (isRunning_.load()) {
177         unique_lock<mutex> lock(signal_->inMutex_);
178         signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
179         if (!isRunning_.load()) {
180             break;
181         }
182         uint32_t index = signal_->inQueue_.front();
183         auto buffer = signal_->inBufferQueue_.front();
184         if (buffer == nullptr) {
185             cout << "Fatal: GetInputBuffer fail" << endl;
186             break;
187         }
188         inputFile_.read(reinterpret_cast<char *>(&size), sizeof(size));
189         if (inputFile_.eof() || inputFile_.gcount() == 0) {
190             buffer->buffer_->memory_->SetSize(1);
191             buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
192             HandleInputBuffer(index);
193             cout << "end buffer\n";
194             break;
195         }
196         if (inputFile_.gcount() != sizeof(size)) {
197             cout << "Fatal: read size fail" << endl;
198             break;
199         }
200         inputFile_.read(reinterpret_cast<char *>(&buffer->buffer_->pts_), sizeof(buffer->buffer_->pts_));
201         if (inputFile_.gcount() != sizeof(buffer->buffer_->pts_)) {
202             cout << "Fatal: read size fail" << endl;
203             break;
204         }
205         inputFile_.read((char *)OH_AVBuffer_GetAddr(buffer), size);
206         if (inputFile_.gcount() != size) {
207             cout << "Fatal: read buffer fail" << endl;
208             break;
209         }
210         buffer->buffer_->memory_->SetSize(size);
211         if (isFirstFrame_) {
212             buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
213             isFirstFrame_ = false;
214         } else {
215             buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
216         }
217         if (HandleInputBuffer(index) != AV_ERR_OK) {
218             cout << "Fatal error, exit" << endl;
219             break;
220         }
221     }
222     inputFile_.close();
223 }
224 
OutputFunc()225 void AudioVividCodeCapiDecoderUnitTest::OutputFunc()
226 {
227     if (!pcmOutputFile_.is_open()) {
228         std::cout << "open " << OUTPUT_VIVID_PCM_FILE_PATH << " failed!" << std::endl;
229     }
230     while (isRunning_.load()) {
231         unique_lock<mutex> lock(signal_->outMutex_);
232         signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
233         if (!isRunning_.load()) {
234             cout << "wait to stop, exit" << endl;
235             break;
236         }
237         uint32_t index = signal_->outQueue_.front();
238         OH_AVBuffer *data = signal_->outBufferQueue_.front();
239         if (data == nullptr) {
240             std::cout << "OutputFunc OH_AVBuffer is nullptr" << std::endl;
241             isRunning_.store(false);
242             signal_->startCond_.notify_all();
243             break;
244         }
245         pcmOutputFile_.write(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(data)), data->buffer_->memory_->GetSize());
246         if (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS) {
247             cout << "decode eos" << endl;
248             isRunning_.store(false);
249             signal_->startCond_.notify_all();
250         }
251         signal_->outBufferQueue_.pop();
252         signal_->outQueue_.pop();
253         EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
254     }
255     pcmOutputFile_.close();
256     signal_->startCond_.notify_all();
257 }
258 
Start()259 int32_t AudioVividCodeCapiDecoderUnitTest::Start()
260 {
261     isRunning_.store(true);
262     inputLoop_ = make_unique<thread>(&AudioVividCodeCapiDecoderUnitTest::InputFunc, this);
263     if (inputLoop_ == nullptr) {
264         cout << "Fatal: No memory" << endl;
265         return OH_AVErrCode::AV_ERR_UNKNOWN;
266     }
267 
268     outputLoop_ = make_unique<thread>(&AudioVividCodeCapiDecoderUnitTest::OutputFunc, this);
269     if (outputLoop_ == nullptr) {
270         cout << "Fatal: No memory" << endl;
271         return OH_AVErrCode::AV_ERR_UNKNOWN;
272     }
273 
274     return OH_AudioCodec_Start(audioDec_);
275 }
276 
Stop()277 int32_t AudioVividCodeCapiDecoderUnitTest::Stop()
278 {
279     isRunning_.store(false);
280     if (!signal_) {
281         return OH_AVErrCode::AV_ERR_UNKNOWN;
282     }
283     signal_->startCond_.notify_all();
284     if (inputLoop_ != nullptr && inputLoop_->joinable()) {
285         {
286             unique_lock<mutex> lock(signal_->inMutex_);
287             signal_->inCond_.notify_all();
288         }
289         inputLoop_->join();
290     }
291 
292     if (outputLoop_ != nullptr && outputLoop_->joinable()) {
293         {
294             unique_lock<mutex> lock(signal_->outMutex_);
295             signal_->outCond_.notify_all();
296         }
297         outputLoop_->join();
298     }
299     return OH_AudioCodec_Stop(audioDec_);
300 }
301 
InitFile(const string & codecName)302 int32_t AudioVividCodeCapiDecoderUnitTest::InitFile(const string &codecName)
303 {
304     if (codecName.compare(CODEC_VIVID_NAME) == 0) {
305         inputFile_.open(INPUT_VIVID_FILE_PATH.data(), std::ios::binary);
306         pcmOutputFile_.open(OUTPUT_VIVID_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary);
307     } else {
308         cout << "Fatal: audio format type not support" << endl;
309         return OH_AVErrCode::AV_ERR_UNKNOWN;
310     }
311 
312     if (!inputFile_.is_open()) {
313         cout << "Fatal: open input file failed" << endl;
314         return OH_AVErrCode::AV_ERR_UNKNOWN;
315     }
316     if (!pcmOutputFile_.is_open()) {
317         cout << "Fatal: open output file failed" << endl;
318         return OH_AVErrCode::AV_ERR_UNKNOWN;
319     }
320     return OH_AVErrCode::AV_ERR_OK;
321 }
322 
CreateCodecFunc(const string & codecName)323 int32_t AudioVividCodeCapiDecoderUnitTest::CreateCodecFunc(const string &codecName)
324 {
325     if (codecName.compare(CODEC_VIVID_NAME) == 0) {
326         audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_VIVID_NAME).data());
327     } else {
328         cout << "audio name not support" << endl;
329         return OH_AVErrCode::AV_ERR_UNKNOWN;
330     }
331 
332     if (audioDec_ == nullptr) {
333         cout << "Fatal: CreateByName fail" << endl;
334         return OH_AVErrCode::AV_ERR_UNKNOWN;
335     }
336 
337     signal_ = new ADecBufferSignal();
338     if (signal_ == nullptr) {
339         cout << "Fatal: create signal fail" << endl;
340         return OH_AVErrCode::AV_ERR_UNKNOWN;
341     }
342     cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
343     int32_t ret = OH_AudioCodec_RegisterCallback(audioDec_, cb_, signal_);
344     if (ret != OH_AVErrCode::AV_ERR_OK) {
345         cout << "Fatal: SetCallback fail" << endl;
346         return OH_AVErrCode::AV_ERR_UNKNOWN;
347     }
348 
349     return OH_AVErrCode::AV_ERR_OK;
350 }
351 
Configure()352 int32_t AudioVividCodeCapiDecoderUnitTest::Configure()
353 {
354     format_ = OH_AVFormat_Create();
355     if (format_ == nullptr) {
356         cout << "Fatal: create format failed" << endl;
357         return OH_AVErrCode::AV_ERR_UNKNOWN;
358     }
359 
360     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
361     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
362 
363     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
364                             OH_BitsPerSample::SAMPLE_S16LE);
365 
366     return OH_AudioCodec_Configure(audioDec_, format_);
367 }
368 
Configure24Bit()369 int32_t AudioVividCodeCapiDecoderUnitTest::Configure24Bit()
370 {
371     format_ = OH_AVFormat_Create();
372     if (format_ == nullptr) {
373         cout << "Fatal: create format failed" << endl;
374         return OH_AVErrCode::AV_ERR_UNKNOWN;
375     }
376 
377     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
378     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
379 
380     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
381                             OH_BitsPerSample::SAMPLE_S24LE);
382 
383     return OH_AudioCodec_Configure(audioDec_, format_);
384 }
385 
386 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_CreateByMime_01, TestSize.Level1)
387 {
388     audioDec_ = OH_AudioCodec_CreateByMime(AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID.data(), false);
389     EXPECT_NE(nullptr, audioDec_);
390     Release();
391 }
392 
393 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_CreateByName_01, TestSize.Level1)
394 {
395     audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_VIVID_NAME).data());
396     EXPECT_NE(nullptr, audioDec_);
397     Release();
398 }
399 
400 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_01, TestSize.Level1)
401 {
402     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
403     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
404     Release();
405 }
406 
407 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_02, TestSize.Level1)
408 {
409     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
410     format_ = OH_AVFormat_Create();
411     EXPECT_NE(nullptr, format_);
412     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), VIVID_MIN_CHANNEL_COUNT);
413     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
414     ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
415     Release();
416 }
417 
418 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_03, TestSize.Level1)
419 {
420     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
421     format_ = OH_AVFormat_Create();
422     EXPECT_NE(nullptr, format_);
423     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), VIVID_MAX_CHANNEL_COUNT);
424     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
425     ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
426     Release();
427 }
428 
429 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_04, TestSize.Level1)
430 {
431     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
432     format_ = OH_AVFormat_Create();
433     EXPECT_NE(nullptr, format_);
434     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
435                             OH_BitsPerSample::SAMPLE_S32LE);
436     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
437     Release();
438 }
439 
440 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_05, TestSize.Level1)
441 {
442     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
443     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
444     Release();
445 }
446 
447 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_01, TestSize.Level1)
448 {
449     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
450     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
451     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
452     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
453     {
454         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60402() 455         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
456     }
457     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
458     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
459     Release();
460 }
461 
462 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_02, TestSize.Level1)
463 {
464     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
465     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
466     ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
467     Release();
468 }
469 
470 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_03, TestSize.Level1)
471 {
472     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
473     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
474     ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
475     Release();
476 }
477 
478 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_01, TestSize.Level1)
479 {
480     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
481     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
482     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
483     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
484     {
485         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60502() 486         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
487     }
488     Release();
489 }
490 
491 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_02, TestSize.Level1)
492 {
493     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
494     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
495     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
496     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
497     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
498     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
499     {
500         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60602() 501         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
502     }
503     Release();
504 }
505 
506 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_03, TestSize.Level1)
507 {
508     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
509     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
510     format_ = OH_AVFormat_Create();
511     EXPECT_NE(nullptr, format_);
512     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
513     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
514     OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), VIVID_MAX_INPUT_SIZE);
515     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
516 
517     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
518     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
519     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
520     {
521         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60702() 522         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
523     }
524     Release();
525 }
526 
527 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_04, TestSize.Level1)
528 {
529     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
530     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
531     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
532     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
533     {
534         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60802() 535         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
536     }
537     Release();
538 }
539 
540 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_05, TestSize.Level1)
541 {
542     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
543     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
544     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
545     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
546     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
547     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
548     {
549         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60902() 550         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
551     }
552     Release();
553 }
554 
555 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Stop_01, TestSize.Level1)
556 {
557     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
558     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
559     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
560     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
561     sleep(1);
562 
563     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
564     Release();
565 }
566 
567 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Stop_02, TestSize.Level1)
568 {
569     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
570     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
571     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
572     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
573     sleep(1);
574 
575     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
576     Release();
577 }
578 
579 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Flush_01, TestSize.Level1)
580 {
581     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
582     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
583     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
584     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
585     {
586         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60a02() 587         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
588     }
589     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
590     Release();
591 }
592 
593 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Flush_02, TestSize.Level1)
594 {
595     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
596     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
597     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
598     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
599     {
600         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60b02() 601         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
602     }
603     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
604     Release();
605 }
606 
607 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_01, TestSize.Level1)
608 {
609     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
610     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
611     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
612     Release();
613 }
614 
615 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_02, TestSize.Level1)
616 {
617     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
618     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
619     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
620     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
621     {
622         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60c02() 623         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
624     }
625     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
626     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
627     Release();
628 }
629 
630 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_03, TestSize.Level1)
631 {
632     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
633     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
634     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
635     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
636     {
637         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60d02() 638         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
639     }
640     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
641     Release();
642 }
643 
644 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_04, TestSize.Level1)
645 {
646     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
647     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
648     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
649     Release();
650 }
651 
652 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_05, TestSize.Level1)
653 {
654     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
655     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
656     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
657     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
658     {
659         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60e02() 660         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
661     }
662     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
663     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
664     Release();
665 }
666 
667 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_06, TestSize.Level1)
668 {
669     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
670     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
671     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
672     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
673     {
674         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e60f02() 675         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
676     }
677     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
678     Release();
679 }
680 
681 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_01, TestSize.Level1)
682 {
683     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
684     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
685     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
686     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
687     {
688         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e61002() 689         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
690     }
691     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
692     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
693 }
694 
695 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_02, TestSize.Level1)
696 {
697     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
698     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
699     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
700 
701     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
702 }
703 
704 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_03, TestSize.Level1)
705 {
706     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
707     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
708     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
709     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
710     {
711         unique_lock<mutex> lock(signal_->startMutex_);
__anon036674e61102() 712         signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
713     }
714     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
715     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
716 }
717 
718 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_04, TestSize.Level1)
719 {
720     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
721     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
722     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
723 
724     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
725 }
726 
727 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_GetOutputFormat_01, TestSize.Level1)
728 {
729     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
730     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
731     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
732 
733     EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioDec_));
734     Release();
735 }
736 
737 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_GetOutputFormat_02, TestSize.Level1)
738 {
739     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
740     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
741     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
742 
743     EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioDec_));
744     Release();
745 }
746 
747 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_IsValid_01, TestSize.Level1)
748 {
749     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
750     bool isValid = false;
751     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_IsValid(audioDec_, &isValid));
752     Release();
753 }
754 
755 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_01, TestSize.Level1)
756 {
757     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
758     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
759     Release();
760 }
761 
762 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_02, TestSize.Level1)
763 {
764     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
765     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
766     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
767     Release();
768 }
769 
770 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_03, TestSize.Level1)
771 {
772     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
773     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
774     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
775     Release();
776 }
777 
778 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_PushInputData_01, TestSize.Level1)
779 {
780     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
781     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
782     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
783     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
784 
785     uint32_t index = 0;
786     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_PushInputBuffer(audioDec_, index));
787     Release();
788 }
789 
790 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_PushInputData_02, TestSize.Level1)
791 {
792     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
793     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
794     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
795     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
796 
797     uint32_t index = 0;
798     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_PushInputBuffer(audioDec_, index));
799     Release();
800 }
801 
802 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_ReleaseOutputBuffer_01, TestSize.Level1)
803 {
804     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
805     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
806     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
807     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
808 
809     uint32_t index = 1024;
810     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
811     Release();
812 }
813 
814 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_ReleaseOutputBuffer_02, TestSize.Level1)
815 {
816     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
817     ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
818     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
819     EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
820 
821     uint32_t index = 1024;
822     EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
823     Release();
824 }
825 } // namespace MediaAVCodec
826 } // namespace OHOS