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 <fstream>
21 #include "native_avcodec_audiodecoder.h"
22 #include "audio_codec_adapter.h"
23 #include "meta/format.h"
24 #include "avcodec_audio_decoder.h"
25 #include "avcodec_codec_name.h"
26 #include "avcodec_common.h"
27 #include "avcodec_errors.h"
28 #include "media_description.h"
29 
30 using namespace std;
31 using namespace testing::ext;
32 using namespace OHOS::MediaAVCodec;
33 
34 namespace {
35 const string CODEC_MP3_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_MP3_NAME);
36 const string CODEC_FLAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_FLAC_NAME);
37 const string CODEC_OPUS_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_OPUS_NAME);
38 const string CODEC_AAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_AAC_NAME);
39 const string OPUS_SO_FILE_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_ext_base.z.so";
40 constexpr uint32_t MAX_CHANNEL_COUNT = 2;
41 constexpr uint32_t INVALID_CHANNEL_COUNT = 3;
42 constexpr uint32_t DEFAULT_SAMPLE_RATE = 8000;
43 constexpr uint32_t INVALID_SAMPLE_RATE = 9999990;
44 constexpr uint32_t DEFAULT_BITRATE = 128000;
45 constexpr uint32_t DEFAULT_WIDTH = 0;
46 constexpr uint32_t DEFAULT_AAC_TYPE = 1;
47 constexpr uint32_t DEFAULT_AAC_LATM_TYPE = 0;
48 } // namespace
49 
50 namespace OHOS {
51 namespace MediaAVCodec {
52 class ADecSignal {
53 public:
54     std::mutex inMutex_;
55     std::mutex outMutex_;
56     std::condition_variable inCond_;
57     std::condition_variable outCond_;
58     std::queue<int32_t> inIdxQueue_;
59     std::queue<std::shared_ptr<AVSharedMemory>> inBufferQueue_;
60     std::queue<std::shared_ptr<AVSharedMemory>> outBufferQueue_;
61     std::queue<int32_t> outIdxQueue_;
62     std::queue<AVCodecBufferInfo> infoQueue_;
63     std::queue<AVCodecBufferFlag> flagQueue_;
64 };
65 
66 class BufferCallback : public AVCodecCallback {
67 public:
BufferCallback(ADecSignal * userData)68     explicit BufferCallback(ADecSignal *userData) : userData_(userData) {}
69     virtual ~BufferCallback() = default;
70     ADecSignal *userData_;
71     void OnError(AVCodecErrorType errorType, int32_t errorCode) override;
72     void OnOutputFormatChanged(const Format &format) override;
73     void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer) override;
74     void OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
75                                  std::shared_ptr<AVSharedMemory> buffer) override;
76 };
77 
OnError(AVCodecErrorType errorType,int32_t errorCode)78 void BufferCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
79 {
80     (void)errorType;
81     cout << "Error errorCode=" << errorCode << endl;
82 }
83 
OnOutputFormatChanged(const Format & format)84 void BufferCallback::OnOutputFormatChanged(const Format &format)
85 {
86     (void)format;
87     cout << "Format Changed" << endl;
88 }
89 
OnInputBufferAvailable(uint32_t index,std::shared_ptr<AVSharedMemory> buffer)90 void BufferCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer)
91 {
92     unique_lock<mutex> lock(userData_->inMutex_);
93     userData_->inIdxQueue_.push(index);
94     userData_->inBufferQueue_.push(buffer);
95     userData_->inCond_.notify_all();
96 }
97 
OnOutputBufferAvailable(uint32_t index,AVCodecBufferInfo info,AVCodecBufferFlag flag,std::shared_ptr<AVSharedMemory> buffer)98 void BufferCallback::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
99                                              std::shared_ptr<AVSharedMemory> buffer)
100 {
101     unique_lock<mutex> lock(userData_->outMutex_);
102     userData_->outIdxQueue_.push(index);
103     userData_->infoQueue_.push(info);
104     userData_->flagQueue_.push(flag);
105     userData_->outBufferQueue_.push(buffer);
106     userData_->outCond_.notify_all();
107     (void)flag;
108 }
109 
110 class AudioCodeDecoderInnerUnitTest : public testing::Test {
111 public:
112     static void SetUpTestCase(void);
113     static void TearDownTestCase(void);
114     void SetUp();
115     void TearDown();
116     int32_t ProceMp3Func();
117     int32_t ProceFlacFunc();
118     int32_t ProceOpusFunc();
119     int32_t ProceAacFunc();
120     int32_t CreateMp3CodecFunc();
121     int32_t CreateFlacCodecFunc();
122     int32_t CreateOpusCodecFunc();
123     int32_t CreateAacCodecFunc();
124     int32_t CheckSoFunc();
125 
126 protected:
127     std::unique_ptr<std::ifstream> soFile_;
128     int32_t index_;
129     int64_t timeStamp_;
130 
131     ADecSignal *signal_;
132 
133     FILE *inFile_;
134     FILE *dumpFd_;
135 
136     OHOS::MediaAVCodec::Format format_;
137     std::shared_ptr<AVCodecAudioDecoder> adec_ = {nullptr};
138 };
139 
SetUpTestCase(void)140 void AudioCodeDecoderInnerUnitTest::SetUpTestCase(void)
141 {
142     cout << "[SetUpTestCase]: " << endl;
143 }
144 
TearDownTestCase(void)145 void AudioCodeDecoderInnerUnitTest::TearDownTestCase(void)
146 {
147     cout << "[TearDownTestCase]: " << endl;
148 }
149 
SetUp(void)150 void AudioCodeDecoderInnerUnitTest::SetUp(void)
151 {
152     cout << "[SetUp]: SetUp!!!" << endl;
153 }
154 
TearDown(void)155 void AudioCodeDecoderInnerUnitTest::TearDown(void)
156 {
157     if (adec_) {
158         adec_->Release();
159     }
160     cout << "[TearDown]: over!!!" << endl;
161 }
162 
CreateMp3CodecFunc(void)163 int32_t AudioCodeDecoderInnerUnitTest::CreateMp3CodecFunc(void)
164 {
165     adec_ = AudioDecoderFactory::CreateByName(CODEC_MP3_NAME);
166     if (adec_ == nullptr) {
167         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
168     }
169 
170     signal_ = new ADecSignal();
171     adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
172     sleep(1);
173     return AVCodecServiceErrCode::AVCS_ERR_OK;
174 }
175 
CreateFlacCodecFunc(void)176 int32_t AudioCodeDecoderInnerUnitTest::CreateFlacCodecFunc(void)
177 {
178     adec_ = AudioDecoderFactory::CreateByName(CODEC_FLAC_NAME);
179     if (adec_ == nullptr) {
180         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
181     }
182 
183     signal_ = new ADecSignal();
184     adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
185     sleep(1);
186     return AVCodecServiceErrCode::AVCS_ERR_OK;
187 }
188 
CreateOpusCodecFunc(void)189 int32_t AudioCodeDecoderInnerUnitTest::CreateOpusCodecFunc(void)
190 {
191     adec_ = AudioDecoderFactory::CreateByName(CODEC_OPUS_NAME);
192     if (adec_ == nullptr) {
193         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
194     }
195 
196     signal_ = new ADecSignal();
197     adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
198     sleep(1);
199     return AVCodecServiceErrCode::AVCS_ERR_OK;
200 }
201 
CreateAacCodecFunc(void)202 int32_t AudioCodeDecoderInnerUnitTest::CreateAacCodecFunc(void)
203 {
204     adec_ = AudioDecoderFactory::CreateByName(CODEC_AAC_NAME);
205     if (adec_ == nullptr) {
206         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
207     }
208 
209     signal_ = new ADecSignal();
210     adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
211     sleep(1);
212     return AVCodecServiceErrCode::AVCS_ERR_OK;
213 }
214 
ProceMp3Func(void)215 int32_t AudioCodeDecoderInnerUnitTest::ProceMp3Func(void)
216 {
217     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
218     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
219     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
220 
221     if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
222         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
223     } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
224         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
225     }
226     return AVCodecServiceErrCode::AVCS_ERR_OK;
227 }
228 
ProceFlacFunc(void)229 int32_t AudioCodeDecoderInnerUnitTest::ProceFlacFunc(void)
230 {
231     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
232     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
233     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
234 
235     if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
236         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
237     } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
238         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
239     }
240     return AVCodecServiceErrCode::AVCS_ERR_OK;
241 }
242 
ProceOpusFunc(void)243 int32_t AudioCodeDecoderInnerUnitTest::ProceOpusFunc(void)
244 {
245     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
246     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
247 
248     if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
249         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
250     } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
251         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
252     }
253     return AVCodecServiceErrCode::AVCS_ERR_OK;
254 }
255 
ProceAacFunc(void)256 int32_t AudioCodeDecoderInnerUnitTest::ProceAacFunc(void)
257 {
258     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
259     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
260     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
261     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
262 
263     if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
264         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
265     } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
266         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
267     }
268     return AVCodecServiceErrCode::AVCS_ERR_OK;
269 }
270 
CheckSoFunc()271 int32_t AudioCodeDecoderInnerUnitTest::CheckSoFunc()
272 {
273     soFile_ = std::make_unique<std::ifstream>(OPUS_SO_FILE_PATH, std::ios::binary);
274     if (!soFile_->is_open()) {
275         cout << "Fatal: Open so file failed" << endl;
276         return false;
277     }
278     soFile_->close();
279     return true;
280 }
281 
282 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_01, TestSize.Level1)
283 {
284     // lack of correct key
285     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
286     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
287     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
288 }
289 
290 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_02, TestSize.Level1)
291 {
292     // correct key input
293     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
294     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
295     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
296     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
297 
298     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
299 }
300 
301 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_03, TestSize.Level1)
302 {
303     // correct key input with redundancy key input
304     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
305     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
306     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
307     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
308     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
309     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
310 }
311 
312 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_04, TestSize.Level1)
313 {
314     // correct key input with wrong value type input
315     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
316     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
317     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
318     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
319     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
320 }
321 
322 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_05, TestSize.Level1)
323 {
324     // correct key input with wrong value type input
325     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
326     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
327     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
328     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
329     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
330 }
331 
332 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_06, TestSize.Level1)
333 {
334     // empty format input
335     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
336     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
337 }
338 
339 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Start_01, TestSize.Level1)
340 {
341     // correct flow 1
342     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
343     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
344 }
345 
346 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Start_02, TestSize.Level1)
347 {
348     // correct flow 2
349     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
350     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
351     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
352     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
353 }
354 
355 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Start_03, TestSize.Level1)
356 {
357     // wrong flow 1
358     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
359     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
360 }
361 
362 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Start_04, TestSize.Level1)
363 {
364     // wrong flow 2
365     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
366     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
367     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
368     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
369 }
370 
371 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Stop_01, TestSize.Level1)
372 {
373     // correct flow 1
374     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
375     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
376     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
377 }
378 
379 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Stop_02, TestSize.Level1)
380 {
381     // correct flow 2
382     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
383     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
384     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
385     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
386     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
387     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
388     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
389 }
390 
391 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Flush_01, TestSize.Level1)
392 {
393     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
394     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
395     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
396 }
397 
398 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Flush_02, TestSize.Level1)
399 {
400     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
401     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
402     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
403     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
404     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
405 }
406 
407 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Reset_01, TestSize.Level1)
408 {
409     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
410     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
411     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
412     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
413 }
414 
415 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Reset_02, TestSize.Level1)
416 {
417     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
418     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
419     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
420     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
421     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
422     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
423     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
424 }
425 
426 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Reset_03, TestSize.Level1)
427 {
428     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
429     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
430     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
431 }
432 
433 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Release_01, TestSize.Level1)
434 {
435     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
436     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
437     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
438     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
439 }
440 
441 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Release_02, TestSize.Level1)
442 {
443     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
444     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
445     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
446     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
447     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
448     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
449     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
450 }
451 
452 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Release_03, TestSize.Level1)
453 {
454     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
455     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
456     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
457 }
458 
459 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_SetParameter_01, TestSize.Level1)
460 {
461     // 尚未实现
462     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
463     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
464     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
465     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
466     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
467 }
468 
469 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_GetOutputFormat_01, TestSize.Level1)
470 {
471     // 尚未实现
472     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
473     EXPECT_EQ(AVCS_ERR_OK, ProceMp3Func());
474     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
475 }
476 
477 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_QueueInputBuffer_01, TestSize.Level1)
478 {
479     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
480     AVCodecBufferInfo info;
481     AVCodecBufferFlag flag = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE;
482 
483     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
484     sleep(1);
485     // case0 传参异常
486     index_ = -1;
487     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
488     // case1 info未赋值
489     index_ = 1024;
490     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
491 
492     // case2 EOS帧数据
493     index_ = 0;
494     info.presentationTimeUs = 0;
495     info.size = 0;
496     info.offset = 0;
497     flag = AVCODEC_BUFFER_FLAG_EOS;
498     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
499     sleep(1);
500 }
501 
502 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_ReleaseOutputBuffer_01, TestSize.Level1)
503 {
504     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
505     EXPECT_EQ(AVCS_ERR_OK, ProceMp3Func());
506 
507     // case1 传参异常
508     index_ = -1;
509     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
510     index_ = 1024;
511     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
512 }
513 
514 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_01, TestSize.Level1)
515 {
516     // lack of correct key
517     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
518     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
519     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
520 }
521 
522 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_02, TestSize.Level1)
523 {
524     // correct key input
525     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
526     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
527     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
528     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
529     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
530 }
531 
532 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_03, TestSize.Level1)
533 {
534     // correct key input with redundancy key input
535     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
536     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
537     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
538     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
539     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
540     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
541 }
542 
543 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_04, TestSize.Level1)
544 {
545     // correct key input with wrong value type input
546     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
547     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
548     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
549     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
550     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
551 }
552 
553 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_05, TestSize.Level1)
554 {
555     // correct key input with wrong value type input
556     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
557     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
558     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
559     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
560     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
561 }
562 
563 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_06, TestSize.Level1)
564 {
565     // empty format input
566     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
567     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
568 }
569 
570 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Start_01, TestSize.Level1)
571 {
572     // correct flow 1
573     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
574     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
575 }
576 
577 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Start_02, TestSize.Level1)
578 {
579     // correct flow 2
580     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
581     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
582     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
583     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
584 }
585 
586 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Start_03, TestSize.Level1)
587 {
588     // wrong flow 1
589     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
590     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
591 }
592 
593 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Start_04, TestSize.Level1)
594 {
595     // wrong flow 2
596     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
597     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
598     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
599     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
600 }
601 
602 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Stop_01, TestSize.Level1)
603 {
604     // correct flow 1
605     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
606     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
607     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
608 }
609 
610 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Stop_02, TestSize.Level1)
611 {
612     // correct flow 2
613     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
614     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
615     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
616     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
617     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
618     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
619 }
620 
621 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Flush_01, TestSize.Level1)
622 {
623     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
624     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
625     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
626 }
627 
628 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Flush_02, TestSize.Level1)
629 {
630     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
631     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
632     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
633     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
634     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
635 }
636 
637 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Reset_01, TestSize.Level1)
638 {
639     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
640     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
641     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
642     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
643 }
644 
645 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Reset_02, TestSize.Level1)
646 {
647     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
648     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
649     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
650     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
651     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
652     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
653 }
654 
655 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Reset_03, TestSize.Level1)
656 {
657     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
658     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
659     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
660 }
661 
662 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Release_01, TestSize.Level1)
663 {
664     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
665     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
666     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
667     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
668 }
669 
670 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Release_02, TestSize.Level1)
671 {
672     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
673     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
674     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
675     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
676     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
677     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
678 }
679 
680 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Release_03, TestSize.Level1)
681 {
682     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
683     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
684     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
685 }
686 
687 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_SetParameter_01, TestSize.Level1)
688 {
689     // 尚未实现
690     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
691     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
692     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
693     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
694     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
695 }
696 
697 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_GetOutputFormat_01, TestSize.Level1)
698 {
699     // 尚未实现
700     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
701     EXPECT_EQ(AVCS_ERR_OK, ProceFlacFunc());
702     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
703 }
704 
705 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_QueueInputBuffer_01, TestSize.Level1)
706 {
707     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
708     AVCodecBufferInfo info;
709     AVCodecBufferFlag flag = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE;
710 
711     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
712     sleep(1);
713     // case0 传参异常
714     index_ = -1;
715     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
716     // case1 info未赋值
717     index_ = 1024;
718     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
719 
720     // case2 EOS帧数据
721     index_ = 0;
722     info.presentationTimeUs = 0;
723     info.size = 0;
724     info.offset = 0;
725     flag = AVCODEC_BUFFER_FLAG_EOS;
726     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
727     sleep(1);
728 }
729 
730 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_ReleaseOutputBuffer_01, TestSize.Level1)
731 {
732     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
733     EXPECT_EQ(AVCS_ERR_OK, ProceFlacFunc());
734 
735     // case1 传参异常
736     index_ = -1;
737     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
738     index_ = 1024;
739     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
740 }
741 
742 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Configure_01, TestSize.Level1)
743 {
744     if (!CheckSoFunc()) {
745         return;
746     }
747     // lack of correct key
748     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
749     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
750     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
751 }
752 
753 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Configure_02, TestSize.Level1)
754 {
755     if (!CheckSoFunc()) {
756         return;
757     }
758     // correct key input
759     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
760     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
761     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
762     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
763     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
764 }
765 
766 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Configure_03, TestSize.Level1)
767 {
768     if (!CheckSoFunc()) {
769         return;
770     }
771     // correct key input with redundancy key input
772     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
773     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
774     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
775     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
776     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
777     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
778 }
779 
780 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Configure_04, TestSize.Level1)
781 {
782     if (!CheckSoFunc()) {
783         return;
784     }
785     // correct key input with wrong value type input
786     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
787     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
788     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
789     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
790     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
791 }
792 
793 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Configure_05, TestSize.Level1)
794 {
795     if (!CheckSoFunc()) {
796         return;
797     }
798     // correct key input with wrong value type input
799     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
800     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
801     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
802     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
803     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
804 }
805 
806 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Configure_06, TestSize.Level1)
807 {
808     if (!CheckSoFunc()) {
809         return;
810     }
811     // empty format input
812     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
813     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
814 }
815 
816 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Start_01, TestSize.Level1)
817 {
818     if (!CheckSoFunc()) {
819         return;
820     }
821     // correct flow 1
822     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
823     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
824 }
825 
826 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Start_02, TestSize.Level1)
827 {
828     if (!CheckSoFunc()) {
829         return;
830     }
831     // correct flow 2
832     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
833     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
834     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
835     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
836 }
837 
838 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Start_03, TestSize.Level1)
839 {
840     if (!CheckSoFunc()) {
841         return;
842     }
843     // wrong flow 1
844     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
845     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
846 }
847 
848 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Start_04, TestSize.Level1)
849 {
850     if (!CheckSoFunc()) {
851         return;
852     }
853     // wrong flow 2
854     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
855     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
856     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
857     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
858 }
859 
860 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Stop_01, TestSize.Level1)
861 {
862     if (!CheckSoFunc()) {
863         return;
864     }
865     // correct flow 1
866     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
867     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
868     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
869 }
870 
871 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Stop_02, TestSize.Level1)
872 {
873     if (!CheckSoFunc()) {
874         return;
875     }
876     // correct flow 2
877     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
878     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
879     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
880     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
881     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
882     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
883 }
884 
885 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Flush_01, TestSize.Level1)
886 {
887     if (!CheckSoFunc()) {
888         return;
889     }
890     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
891     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
892     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
893 }
894 
895 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Flush_02, TestSize.Level1)
896 {
897     if (!CheckSoFunc()) {
898         return;
899     }
900     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
901     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
902     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
903     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
904     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
905 }
906 
907 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Reset_01, TestSize.Level1)
908 {
909     if (!CheckSoFunc()) {
910         return;
911     }
912     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
913     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
914     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
915     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
916 }
917 
918 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Reset_02, TestSize.Level1)
919 {
920     if (!CheckSoFunc()) {
921         return;
922     }
923     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
924     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
925     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
926     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
927     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
928 }
929 
930 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Reset_03, TestSize.Level1)
931 {
932     if (!CheckSoFunc()) {
933         return;
934     }
935     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
936     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
937     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
938 }
939 
940 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Release_01, TestSize.Level1)
941 {
942     if (!CheckSoFunc()) {
943         return;
944     }
945     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
946     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
947     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
948     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
949 }
950 
951 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Release_02, TestSize.Level1)
952 {
953     if (!CheckSoFunc()) {
954         return;
955     }
956     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
957     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
958     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
959     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
960     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
961 }
962 
963 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_Release_03, TestSize.Level1)
964 {
965     if (!CheckSoFunc()) {
966         return;
967     }
968     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
969     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
970     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
971 }
972 
973 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_SetParameter_01, TestSize.Level1)
974 {
975     if (!CheckSoFunc()) {
976         return;
977     }
978     // 尚未实现
979     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
980     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
981     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
982     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
983 }
984 
985 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_GetOutputFormat_01, TestSize.Level1)
986 {
987     if (!CheckSoFunc()) {
988         return;
989     }
990     // 尚未实现
991     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
992     EXPECT_EQ(AVCS_ERR_OK, ProceOpusFunc());
993     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
994 }
995 
996 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_QueueInputBuffer_01, TestSize.Level1)
997 {
998     if (!CheckSoFunc()) {
999         return;
1000     }
1001     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1002     AVCodecBufferInfo info;
1003     AVCodecBufferFlag flag = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE;
1004 
1005     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1006     sleep(1);
1007     // case0 传参异常
1008     index_ = -1;
1009     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
1010     // case1 info未赋值
1011     index_ = 1024;
1012     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
1013 
1014     // case2 EOS帧数据
1015     index_ = 0;
1016     info.presentationTimeUs = 0;
1017     info.size = 0;
1018     info.offset = 0;
1019     flag = AVCODEC_BUFFER_FLAG_EOS;
1020     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
1021     sleep(1);
1022 }
1023 
1024 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Opus_ReleaseOutputBuffer_01, TestSize.Level1)
1025 {
1026     if (!CheckSoFunc()) {
1027         return;
1028     }
1029     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1030     EXPECT_EQ(AVCS_ERR_OK, ProceOpusFunc());
1031 
1032     // case1 传参异常
1033     index_ = -1;
1034     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
1035     index_ = 1024;
1036     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
1037 }
1038 
1039 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_01, TestSize.Level1)
1040 {
1041     // lack of correct key
1042     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1043     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1044     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
1045 }
1046 
1047 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_02, TestSize.Level1)
1048 {
1049     // correct key input
1050     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1051     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1052     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1053     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1054     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
1055     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1056 }
1057 
1058 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_03, TestSize.Level1)
1059 {
1060     // correct key input with redundancy key input
1061     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1062     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1063     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1064     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1065     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1066     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
1067     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1068 }
1069 
1070 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_04, TestSize.Level1)
1071 {
1072     // correct key input with wrong value type input
1073     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1074     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1075     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1076     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1077     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
1078     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1079 }
1080 
1081 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_05, TestSize.Level1)
1082 {
1083     // correct key input with wrong value type input
1084     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1085     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
1086     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
1087     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1088     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
1089     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1090 }
1091 
1092 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_06, TestSize.Level1)
1093 {
1094     // correct key input
1095     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1096     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1097     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1098     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1099     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
1100     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1101 }
1102 
1103 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_07, TestSize.Level1)
1104 {
1105     // correct key input with redundancy key input
1106     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1107     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1108     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1109     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1110     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1111     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
1112     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1113 }
1114 
1115 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_08, TestSize.Level1)
1116 {
1117     // correct key input with wrong value type input
1118     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1119     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1120     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1121     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1122     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
1123     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1124 }
1125 
1126 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_09, TestSize.Level1)
1127 {
1128     // correct key input with wrong value type input
1129     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1130     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
1131     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
1132     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1133     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
1134     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1135 }
1136 
1137 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_10, TestSize.Level1)
1138 {
1139     // empty format input
1140     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1141     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1142 }
1143 
1144 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Start_01, TestSize.Level1)
1145 {
1146     // correct flow 1
1147     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1148     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1149 }
1150 
1151 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Start_02, TestSize.Level1)
1152 {
1153     // correct flow 2
1154     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1155     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1156     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1157     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
1158 }
1159 
1160 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Start_03, TestSize.Level1)
1161 {
1162     // wrong flow 1
1163     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1164     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
1165 }
1166 
1167 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Start_04, TestSize.Level1)
1168 {
1169     // wrong flow 2
1170     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1171     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1172     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1173     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
1174 }
1175 
1176 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Stop_01, TestSize.Level1)
1177 {
1178     // correct flow 1
1179     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1180     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1181     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1182 }
1183 
1184 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Stop_02, TestSize.Level1)
1185 {
1186     // correct flow 2
1187     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1188     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1189     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1190     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1191     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1192     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
1193     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1194     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1195 }
1196 
1197 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Flush_01, TestSize.Level1)
1198 {
1199     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1200     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1201     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
1202 }
1203 
1204 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Flush_02, TestSize.Level1)
1205 {
1206     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1207     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1208     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1209     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1210     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
1211 }
1212 
1213 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Reset_01, TestSize.Level1)
1214 {
1215     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1216     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1217     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1218     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
1219 }
1220 
1221 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Reset_02, TestSize.Level1)
1222 {
1223     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1224     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1225     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1226     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1227     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1228     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
1229     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1230     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
1231 }
1232 
1233 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Reset_03, TestSize.Level1)
1234 {
1235     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1236     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1237     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
1238 }
1239 
1240 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Release_01, TestSize.Level1)
1241 {
1242     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1243     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1244     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1245     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1246 }
1247 
1248 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Release_02, TestSize.Level1)
1249 {
1250     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1251     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1252     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1253     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1254     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1255     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
1256     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1257     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1258 }
1259 
1260 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Release_03, TestSize.Level1)
1261 {
1262     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1263     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1264     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1265 }
1266 
1267 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_SetParameter_01, TestSize.Level1)
1268 {
1269     // 尚未实现
1270     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1271     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1272     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1273     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1274     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
1275 }
1276 
1277 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_GetOutputFormat_01, TestSize.Level1)
1278 {
1279     // 尚未实现
1280     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1281     EXPECT_EQ(AVCS_ERR_OK, ProceAacFunc());
1282     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
1283 }
1284 
1285 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_QueueInputBuffer_01, TestSize.Level1)
1286 {
1287     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1288     AVCodecBufferInfo info;
1289     AVCodecBufferFlag flag = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE;
1290 
1291     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1292     sleep(1);
1293     // case0 传参异常
1294     index_ = -1;
1295     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
1296     // case1 info未赋值
1297     index_ = 1024;
1298     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
1299 
1300     // case2 EOS帧数据
1301     index_ = 0;
1302     info.presentationTimeUs = 0;
1303     info.size = 0;
1304     info.offset = 0;
1305     flag = AVCODEC_BUFFER_FLAG_EOS;
1306     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
1307     sleep(1);
1308 }
1309 
1310 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_ReleaseOutputBuffer_01, TestSize.Level1)
1311 {
1312     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1313     EXPECT_EQ(AVCS_ERR_OK, ProceAacFunc());
1314 
1315     // case1 传参异常
1316     index_ = -1;
1317     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
1318     index_ = 1024;
1319     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
1320 }
1321 } // namespace MediaAVCodec
1322 } // namespace OHOS