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