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 "native_avcodec_audiodecoder.h"
21 #include "audio_codec_adapter.h"
22 #include "format.h"
23 #include "avcodec_audio_decoder.h"
24 #include "avcodec_codec_name.h"
25 #include "avcodec_common.h"
26 #include "avcodec_errors.h"
27 #include "media_description.h"
28
29 using namespace std;
30 using namespace testing::ext;
31 using namespace OHOS::MediaAVCodec;
32
33 namespace {
34 const string CODEC_MP3_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_MP3_NAME);
35 const string CODEC_FLAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_FLAC_NAME);
36 const string CODEC_AAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_AAC_NAME);
37 constexpr uint32_t MAX_CHANNEL_COUNT = 2;
38 constexpr uint32_t INVALID_CHANNEL_COUNT = 3;
39 constexpr uint32_t DEFAULT_SAMPLE_RATE = 8000;
40 constexpr uint32_t INVALID_SAMPLE_RATE = 9999990;
41 constexpr uint32_t DEFAULT_BITRATE = 128000;
42 constexpr uint32_t DEFAULT_WIDTH = 0;
43 constexpr uint32_t DEFAULT_AAC_TYPE = 1;
44 constexpr uint32_t DEFAULT_AAC_LATM_TYPE = 0;
45 } // namespace
46
47 namespace OHOS {
48 namespace MediaAVCodec {
49 class ADecSignal {
50 public:
51 std::mutex inMutex_;
52 std::mutex outMutex_;
53 std::condition_variable inCond_;
54 std::condition_variable outCond_;
55 std::queue<int32_t> inIdxQueue_;
56 std::queue<std::shared_ptr<AVSharedMemory>> inBufferQueue_;
57 std::queue<std::shared_ptr<AVSharedMemory>> outBufferQueue_;
58 std::queue<int32_t> outIdxQueue_;
59 std::queue<AVCodecBufferInfo> infoQueue_;
60 std::queue<AVCodecBufferFlag> flagQueue_;
61 };
62
63 class BufferCallback : public AVCodecCallback {
64 public:
BufferCallback(ADecSignal * userData)65 explicit BufferCallback(ADecSignal *userData) : userData_(userData) {}
66 virtual ~BufferCallback() = default;
67 ADecSignal *userData_;
68 void OnError(AVCodecErrorType errorType, int32_t errorCode) override;
69 void OnOutputFormatChanged(const Format &format) override;
70 void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer) override;
71 void OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
72 std::shared_ptr<AVSharedMemory> buffer) override;
73 };
74
OnError(AVCodecErrorType errorType,int32_t errorCode)75 void BufferCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
76 {
77 (void)errorType;
78 cout << "Error errorCode=" << errorCode << endl;
79 }
80
OnOutputFormatChanged(const Format & format)81 void BufferCallback::OnOutputFormatChanged(const Format &format)
82 {
83 (void)format;
84 cout << "Format Changed" << endl;
85 }
86
OnInputBufferAvailable(uint32_t index,std::shared_ptr<AVSharedMemory> buffer)87 void BufferCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer)
88 {
89 unique_lock<mutex> lock(userData_->inMutex_);
90 userData_->inIdxQueue_.push(index);
91 userData_->inBufferQueue_.push(buffer);
92 userData_->inCond_.notify_all();
93 }
94
OnOutputBufferAvailable(uint32_t index,AVCodecBufferInfo info,AVCodecBufferFlag flag,std::shared_ptr<AVSharedMemory> buffer)95 void BufferCallback::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
96 std::shared_ptr<AVSharedMemory> buffer)
97 {
98 unique_lock<mutex> lock(userData_->outMutex_);
99 userData_->outIdxQueue_.push(index);
100 userData_->infoQueue_.push(info);
101 userData_->flagQueue_.push(flag);
102 userData_->outBufferQueue_.push(buffer);
103 userData_->outCond_.notify_all();
104 (void)flag;
105 }
106
107 class AudioCodeDecoderInnerUnitTest : public testing::Test {
108 public:
109 static void SetUpTestCase(void);
110 static void TearDownTestCase(void);
111 void SetUp();
112 void TearDown();
113 int32_t ProceMp3Func();
114 int32_t ProceFlacFunc();
115 int32_t ProceAacFunc();
116 int32_t CreateMp3CodecFunc();
117 int32_t CreateFlacCodecFunc();
118 int32_t CreateAacCodecFunc();
119
120 protected:
121 int32_t index_;
122 int64_t timeStamp_;
123
124 ADecSignal *signal_;
125
126 FILE *inFile_;
127 FILE *dumpFd_;
128
129 OHOS::MediaAVCodec::Format format_;
130 std::shared_ptr<AVCodecAudioDecoder> adec_ = {nullptr};
131 };
132
SetUpTestCase(void)133 void AudioCodeDecoderInnerUnitTest::SetUpTestCase(void)
134 {
135 cout << "[SetUpTestCase]: " << endl;
136 }
137
TearDownTestCase(void)138 void AudioCodeDecoderInnerUnitTest::TearDownTestCase(void)
139 {
140 cout << "[TearDownTestCase]: " << endl;
141 }
142
SetUp(void)143 void AudioCodeDecoderInnerUnitTest::SetUp(void)
144 {
145 cout << "[SetUp]: SetUp!!!" << endl;
146 }
147
TearDown(void)148 void AudioCodeDecoderInnerUnitTest::TearDown(void)
149 {
150 adec_->Release();
151 cout << "[TearDown]: over!!!" << endl;
152 }
153
CreateMp3CodecFunc(void)154 int32_t AudioCodeDecoderInnerUnitTest::CreateMp3CodecFunc(void)
155 {
156 adec_ = AudioDecoderFactory::CreateByName(CODEC_MP3_NAME);
157 if (adec_ == nullptr) {
158 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
159 }
160
161 signal_ = new ADecSignal();
162 adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
163 sleep(1);
164 return AVCodecServiceErrCode::AVCS_ERR_OK;
165 }
166
CreateFlacCodecFunc(void)167 int32_t AudioCodeDecoderInnerUnitTest::CreateFlacCodecFunc(void)
168 {
169 adec_ = AudioDecoderFactory::CreateByName(CODEC_FLAC_NAME);
170 if (adec_ == nullptr) {
171 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
172 }
173
174 signal_ = new ADecSignal();
175 adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
176 sleep(1);
177 return AVCodecServiceErrCode::AVCS_ERR_OK;
178 }
179
CreateAacCodecFunc(void)180 int32_t AudioCodeDecoderInnerUnitTest::CreateAacCodecFunc(void)
181 {
182 adec_ = AudioDecoderFactory::CreateByName(CODEC_AAC_NAME);
183 if (adec_ == nullptr) {
184 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
185 }
186
187 signal_ = new ADecSignal();
188 adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
189 sleep(1);
190 return AVCodecServiceErrCode::AVCS_ERR_OK;
191 }
192
ProceMp3Func(void)193 int32_t AudioCodeDecoderInnerUnitTest::ProceMp3Func(void)
194 {
195 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
196 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
197 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
198
199 if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
200 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
201 } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
202 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
203 }
204 return AVCodecServiceErrCode::AVCS_ERR_OK;
205 }
206
ProceFlacFunc(void)207 int32_t AudioCodeDecoderInnerUnitTest::ProceFlacFunc(void)
208 {
209 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
210 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
211 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
212
213 if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
214 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
215 } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
216 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
217 }
218 return AVCodecServiceErrCode::AVCS_ERR_OK;
219 }
220
ProceAacFunc(void)221 int32_t AudioCodeDecoderInnerUnitTest::ProceAacFunc(void)
222 {
223 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
224 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
225 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
226 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
227
228 if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
229 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
230 } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
231 return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
232 }
233 return AVCodecServiceErrCode::AVCS_ERR_OK;
234 }
235
236 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_01, TestSize.Level1)
237 {
238 // lack of correct key
239 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
240 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
241 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
242 }
243
244 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_02, TestSize.Level1)
245 {
246 // correct key input
247 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
248 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
249 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
250 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
251
252 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
253 }
254
255 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_03, TestSize.Level1)
256 {
257 // correct key input with redundancy key input
258 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
259 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
260 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
261 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
262 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
263 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
264 }
265
266 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_04, TestSize.Level1)
267 {
268 // correct key input with wrong value type input
269 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
270 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
271 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
272 format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
273 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
274 }
275
276 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_05, TestSize.Level1)
277 {
278 // correct key input with wrong value type input
279 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
280 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
281 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
282 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
283 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
284 }
285
286 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Configure_06, TestSize.Level1)
287 {
288 // empty format input
289 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
290 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
291 }
292
293 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Start_01, TestSize.Level1)
294 {
295 // correct flow 1
296 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
297 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
298 }
299
300 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Start_02, TestSize.Level1)
301 {
302 // correct flow 2
303 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
304 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
305 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
306 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
307 }
308
309 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Start_03, TestSize.Level1)
310 {
311 // wrong flow 1
312 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
313 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
314 }
315
316 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Start_04, TestSize.Level1)
317 {
318 // wrong flow 2
319 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
320 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
321 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
322 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
323 }
324
325 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Stop_01, TestSize.Level1)
326 {
327 // correct flow 1
328 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
329 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
330 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
331 }
332
333 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Stop_02, TestSize.Level1)
334 {
335 // correct flow 2
336 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
337 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
338 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
339 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
340 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
341 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
342 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
343 }
344
345 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Flush_01, TestSize.Level1)
346 {
347 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
348 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
349 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
350 }
351
352 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Flush_02, TestSize.Level1)
353 {
354 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
355 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
356 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
357 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
358 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
359 }
360
361 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Reset_01, TestSize.Level1)
362 {
363 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
364 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
365 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
366 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
367 }
368
369 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Reset_02, TestSize.Level1)
370 {
371 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
372 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
373 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
374 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
375 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
376 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
377 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
378 }
379
380 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Reset_03, TestSize.Level1)
381 {
382 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
383 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
384 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
385 }
386
387 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Release_01, TestSize.Level1)
388 {
389 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
390 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
391 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
392 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
393 }
394
395 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Release_02, TestSize.Level1)
396 {
397 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
398 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
399 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
400 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
401 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
402 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
403 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
404 }
405
406 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_Release_03, TestSize.Level1)
407 {
408 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
409 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
410 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
411 }
412
413 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_SetParameter_01, TestSize.Level1)
414 {
415 // 尚未实现
416 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
417 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
418 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
419 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
420 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
421 }
422
423 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_GetOutputFormat_01, TestSize.Level1)
424 {
425 // 尚未实现
426 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
427 EXPECT_EQ(AVCS_ERR_OK, ProceMp3Func());
428 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
429 }
430
431 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_QueueInputBuffer_01, TestSize.Level1)
432 {
433 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
434 AVCodecBufferInfo info;
435 AVCodecBufferFlag flag = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE;
436
437 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
438 sleep(1);
439 // case0 传参异常
440 index_ = -1;
441 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
442 // case1 info未赋值
443 index_ = 1024;
444 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
445
446 // case2 EOS帧数据
447 index_ = 0;
448 info.presentationTimeUs = 0;
449 info.size = 0;
450 info.offset = 0;
451 flag = AVCODEC_BUFFER_FLAG_EOS;
452 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
453 sleep(1);
454 }
455
456 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Mp3_ReleaseOutputBuffer_01, TestSize.Level1)
457 {
458 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
459 EXPECT_EQ(AVCS_ERR_OK, ProceMp3Func());
460
461 // case1 传参异常
462 index_ = -1;
463 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
464 index_ = 1024;
465 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
466 }
467
468 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_01, TestSize.Level1)
469 {
470 // lack of correct key
471 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
472 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
473 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
474 }
475
476 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_02, TestSize.Level1)
477 {
478 // correct key input
479 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
480 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
481 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
482 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
483 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
484 }
485
486 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_03, TestSize.Level1)
487 {
488 // correct key input with redundancy key input
489 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
490 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
491 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
492 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
493 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
494 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
495 }
496
497 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_04, TestSize.Level1)
498 {
499 // correct key input with wrong value type input
500 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
501 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
502 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
503 format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
504 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
505 }
506
507 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_05, TestSize.Level1)
508 {
509 // correct key input with wrong value type input
510 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
511 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
512 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
513 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
514 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
515 }
516
517 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Configure_06, TestSize.Level1)
518 {
519 // empty format input
520 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
521 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
522 }
523
524 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Start_01, TestSize.Level1)
525 {
526 // correct flow 1
527 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
528 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
529 }
530
531 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Start_02, TestSize.Level1)
532 {
533 // correct flow 2
534 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
535 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
536 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
537 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
538 }
539
540 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Start_03, TestSize.Level1)
541 {
542 // wrong flow 1
543 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
544 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
545 }
546
547 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Start_04, TestSize.Level1)
548 {
549 // wrong flow 2
550 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
551 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
552 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
553 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
554 }
555
556 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Stop_01, TestSize.Level1)
557 {
558 // correct flow 1
559 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
560 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
561 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
562 }
563
564 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Stop_02, TestSize.Level1)
565 {
566 // correct flow 2
567 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
568 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
569 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
570 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
571 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
572 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
573 }
574
575 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Flush_01, TestSize.Level1)
576 {
577 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
578 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
579 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
580 }
581
582 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Flush_02, TestSize.Level1)
583 {
584 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
585 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
586 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
587 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
588 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
589 }
590
591 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Reset_01, TestSize.Level1)
592 {
593 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
594 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
595 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
596 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
597 }
598
599 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Reset_02, TestSize.Level1)
600 {
601 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
602 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
603 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
604 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
605 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
606 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
607 }
608
609 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Reset_03, TestSize.Level1)
610 {
611 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
612 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
613 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
614 }
615
616 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Release_01, TestSize.Level1)
617 {
618 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
619 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
620 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
621 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
622 }
623
624 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Release_02, TestSize.Level1)
625 {
626 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
627 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
628 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
629 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
630 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
631 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
632 }
633
634 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_Release_03, TestSize.Level1)
635 {
636 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
637 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
638 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
639 }
640
641 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_SetParameter_01, TestSize.Level1)
642 {
643 // 尚未实现
644 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
645 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
646 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
647 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
648 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
649 }
650
651 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_GetOutputFormat_01, TestSize.Level1)
652 {
653 // 尚未实现
654 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
655 EXPECT_EQ(AVCS_ERR_OK, ProceFlacFunc());
656 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
657 }
658
659 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_QueueInputBuffer_01, TestSize.Level1)
660 {
661 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
662 AVCodecBufferInfo info;
663 AVCodecBufferFlag flag = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE;
664
665 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
666 sleep(1);
667 // case0 传参异常
668 index_ = -1;
669 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
670 // case1 info未赋值
671 index_ = 1024;
672 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
673
674 // case2 EOS帧数据
675 index_ = 0;
676 info.presentationTimeUs = 0;
677 info.size = 0;
678 info.offset = 0;
679 flag = AVCODEC_BUFFER_FLAG_EOS;
680 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
681 sleep(1);
682 }
683
684 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Flac_ReleaseOutputBuffer_01, TestSize.Level1)
685 {
686 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
687 EXPECT_EQ(AVCS_ERR_OK, ProceFlacFunc());
688
689 // case1 传参异常
690 index_ = -1;
691 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
692 index_ = 1024;
693 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
694 }
695
696 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_01, TestSize.Level1)
697 {
698 // lack of correct key
699 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
700 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
701 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
702 }
703
704 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_02, TestSize.Level1)
705 {
706 // correct key input
707 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
708 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
709 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
710 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
711 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
712 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
713 }
714
715 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_03, TestSize.Level1)
716 {
717 // correct key input with redundancy key input
718 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
719 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
720 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
721 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
722 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
723 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
724 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
725 }
726
727 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_04, TestSize.Level1)
728 {
729 // correct key input with wrong value type input
730 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
731 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
732 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
733 format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
734 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
735 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
736 }
737
738 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_05, TestSize.Level1)
739 {
740 // correct key input with wrong value type input
741 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
742 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
743 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
744 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
745 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
746 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
747 }
748
749 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_06, TestSize.Level1)
750 {
751 // correct key input
752 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
753 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
754 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
755 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
756 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
757 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
758 }
759
760 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_07, TestSize.Level1)
761 {
762 // correct key input with redundancy key input
763 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
764 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
765 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
766 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
767 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
768 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
769 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
770 }
771
772 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_08, TestSize.Level1)
773 {
774 // correct key input with wrong value type input
775 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
776 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
777 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
778 format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
779 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
780 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
781 }
782
783 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_09, TestSize.Level1)
784 {
785 // correct key input with wrong value type input
786 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
787 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
788 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
789 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
790 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
791 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
792 }
793
794 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Configure_10, TestSize.Level1)
795 {
796 // empty format input
797 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
798 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
799 }
800
801 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Start_01, TestSize.Level1)
802 {
803 // correct flow 1
804 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
805 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
806 }
807
808 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Start_02, TestSize.Level1)
809 {
810 // correct flow 2
811 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
812 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
813 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
814 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
815 }
816
817 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Start_03, TestSize.Level1)
818 {
819 // wrong flow 1
820 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
821 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
822 }
823
824 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Start_04, TestSize.Level1)
825 {
826 // wrong flow 2
827 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
828 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
829 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
830 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
831 }
832
833 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Stop_01, TestSize.Level1)
834 {
835 // correct flow 1
836 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
837 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
838 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
839 }
840
841 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Stop_02, TestSize.Level1)
842 {
843 // correct flow 2
844 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
845 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
846 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
847 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
848 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
849 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
850 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
851 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
852 }
853
854 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Flush_01, TestSize.Level1)
855 {
856 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
857 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
858 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
859 }
860
861 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Flush_02, TestSize.Level1)
862 {
863 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
864 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
865 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
866 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
867 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
868 }
869
870 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Reset_01, TestSize.Level1)
871 {
872 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
873 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
874 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
875 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
876 }
877
878 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Reset_02, TestSize.Level1)
879 {
880 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
881 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
882 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
883 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
884 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
885 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
886 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
887 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
888 }
889
890 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Reset_03, TestSize.Level1)
891 {
892 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
893 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
894 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
895 }
896
897 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Release_01, TestSize.Level1)
898 {
899 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
900 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
901 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
902 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
903 }
904
905 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Release_02, TestSize.Level1)
906 {
907 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
908 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
909 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
910 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
911 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
912 format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
913 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
914 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
915 }
916
917 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_Release_03, TestSize.Level1)
918 {
919 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
920 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
921 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
922 }
923
924 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_SetParameter_01, TestSize.Level1)
925 {
926 // 尚未实现
927 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
928 format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
929 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
930 format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
931 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
932 }
933
934 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_GetOutputFormat_01, TestSize.Level1)
935 {
936 // 尚未实现
937 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
938 EXPECT_EQ(AVCS_ERR_OK, ProceAacFunc());
939 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
940 }
941
942 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_QueueInputBuffer_01, TestSize.Level1)
943 {
944 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
945 AVCodecBufferInfo info;
946 AVCodecBufferFlag flag = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE;
947
948 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
949 sleep(1);
950 // case0 传参异常
951 index_ = -1;
952 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
953 // case1 info未赋值
954 index_ = 1024;
955 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
956
957 // case2 EOS帧数据
958 index_ = 0;
959 info.presentationTimeUs = 0;
960 info.size = 0;
961 info.offset = 0;
962 flag = AVCODEC_BUFFER_FLAG_EOS;
963 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
964 sleep(1);
965 }
966
967 HWTEST_F(AudioCodeDecoderInnerUnitTest, audioDecoder_Aac_ReleaseOutputBuffer_01, TestSize.Level1)
968 {
969 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
970 EXPECT_EQ(AVCS_ERR_OK, ProceAacFunc());
971
972 // case1 传参异常
973 index_ = -1;
974 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
975 index_ = 1024;
976 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
977 }
978 } // namespace MediaAVCodec
979 } // namespace OHOS