• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <atomic>
16 #include <iostream>
17 #include <fstream>
18 #include <queue>
19 #include <string>
20 #include <thread>
21 #include "gtest/gtest.h"
22 #include "avcodec_audio_avbuffer_decoder_demo.h"
23 
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::MediaAVCodec;
28 using namespace OHOS::MediaAVCodec::AudioBufferDemo;
29 
30 namespace {
31 class ParamCheckTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp() override;
36     void TearDown() override;
37 };
38 
SetUpTestCase()39 void ParamCheckTest::SetUpTestCase() {}
TearDownTestCase()40 void ParamCheckTest::TearDownTestCase() {}
SetUp()41 void ParamCheckTest::SetUp() {}
TearDown()42 void ParamCheckTest::TearDown() {}
43 
44 } // namespace
45 
46 /**
47  * @tc.number    : PARAM_CHECK_001
48  * @tc.name      : CreateByMime - mime param check
49  * @tc.desc      : param check test
50  */
51 HWTEST_F(ParamCheckTest, PARAM_CHECK_001, TestSize.Level2)
52 {
53     OH_AVCodec *codec = nullptr;
54     OH_AVErrCode result0;
55     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
56     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
57     ASSERT_NE(codec, nullptr);
58     result0 = aDecBufferDemo->Destroy(codec);
59     ASSERT_EQ(result0, AV_ERR_OK);
60 
61     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
62     ASSERT_NE(codec, nullptr);
63     result0 = aDecBufferDemo->Destroy(codec);
64     ASSERT_EQ(result0, AV_ERR_OK);
65 
66     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
67     ASSERT_NE(codec, nullptr);
68     result0 = aDecBufferDemo->Destroy(codec);
69     ASSERT_EQ(result0, AV_ERR_OK);
70 
71     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS);
72     ASSERT_NE(codec, nullptr);
73     result0 = aDecBufferDemo->Destroy(codec);
74     ASSERT_EQ(result0, AV_ERR_OK);
75 
76     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
77     ASSERT_NE(codec, nullptr);
78     result0 = aDecBufferDemo->Destroy(codec);
79     ASSERT_EQ(result0, AV_ERR_OK);
80 
81     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
82     ASSERT_NE(codec, nullptr);
83     result0 = aDecBufferDemo->Destroy(codec);
84     ASSERT_EQ(result0, AV_ERR_OK);
85 
86     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
87     ASSERT_NE(codec, nullptr);
88     result0 = aDecBufferDemo->Destroy(codec);
89     ASSERT_EQ(result0, AV_ERR_OK);
90 
91     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711A);
92     ASSERT_NE(codec, nullptr);
93     result0 = aDecBufferDemo->Destroy(codec);
94     ASSERT_EQ(result0, AV_ERR_OK);
95 
96     codec = aDecBufferDemo->CreateByMime("aaa");
97     ASSERT_EQ(codec, nullptr);
98     result0 = aDecBufferDemo->Destroy(codec);
99     ASSERT_NE(result0, AV_ERR_OK);
100 
101     delete aDecBufferDemo;
102 }
103 
104 /**
105  * @tc.number    : PARAM_CHECK_002
106  * @tc.name      : CreateByName - mime param check
107  * @tc.desc      : param check test
108  */
109 HWTEST_F(ParamCheckTest, PARAM_CHECK_002, TestSize.Level2)
110 {
111     OH_AVCodec *codec = nullptr;
112     OH_AVErrCode result0;
113     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
114     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.AAC");
115     ASSERT_NE(codec, nullptr);
116     result0 = aDecBufferDemo->Destroy(codec);
117     ASSERT_EQ(result0, AV_ERR_OK);
118 
119     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.Flac");
120     ASSERT_NE(codec, nullptr);
121     result0 = aDecBufferDemo->Destroy(codec);
122     ASSERT_EQ(result0, AV_ERR_OK);
123 
124     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
125     ASSERT_NE(codec, nullptr);
126     result0 = aDecBufferDemo->Destroy(codec);
127     ASSERT_EQ(result0, AV_ERR_OK);
128 
129     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.Vorbis");
130     ASSERT_NE(codec, nullptr);
131     result0 = aDecBufferDemo->Destroy(codec);
132     ASSERT_EQ(result0, AV_ERR_OK);
133 
134     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.Amrnb");
135     ASSERT_NE(codec, nullptr);
136     result0 = aDecBufferDemo->Destroy(codec);
137     ASSERT_EQ(result0, AV_ERR_OK);
138 
139     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.Amrwb");
140     ASSERT_NE(codec, nullptr);
141     result0 = aDecBufferDemo->Destroy(codec);
142     ASSERT_EQ(result0, AV_ERR_OK);
143 
144     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.G711mu");
145     ASSERT_NE(codec, nullptr);
146     result0 = aDecBufferDemo->Destroy(codec);
147     ASSERT_EQ(result0, AV_ERR_OK);
148 
149     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.G711a");
150     ASSERT_NE(codec, nullptr);
151     result0 = aDecBufferDemo->Destroy(codec);
152     ASSERT_EQ(result0, AV_ERR_OK);
153 
154     codec = aDecBufferDemo->CreateByName("aaa");
155     ASSERT_EQ(codec, nullptr);
156     result0 = aDecBufferDemo->Destroy(codec);
157     ASSERT_NE(result0, AV_ERR_OK);
158 
159     delete aDecBufferDemo;
160 }
161 
162 /**
163  * @tc.number    : PARAM_CHECK_003
164  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_AAC) param check
165  * @tc.desc      : param check test
166  */
167 HWTEST_F(ParamCheckTest, PARAM_CHECK_003, TestSize.Level2)
168 {
169     OH_AVCodec *codec = nullptr;
170     OH_AVFormat *format = OH_AVFormat_Create();
171     int32_t channel = 2;
172     int32_t sampleRate = 48000;
173     OH_AVErrCode result0;
174     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
175     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
176     result0 = aDecBufferDemo->SetCallback(codec);
177     channel = 1;
178     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
179     ASSERT_EQ(result0, AV_ERR_OK);
180     result0 = aDecBufferDemo->Destroy(codec);
181 
182     format = OH_AVFormat_Create();
183     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
184     result0 = aDecBufferDemo->SetCallback(codec);
185     channel = 8;
186     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
187     ASSERT_EQ(result0, AV_ERR_OK);
188     result0 = aDecBufferDemo->Destroy(codec);
189 
190     format = OH_AVFormat_Create();
191     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
192     result0 = aDecBufferDemo->SetCallback(codec);
193     channel = 0;
194     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
195     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
196     result0 = aDecBufferDemo->Destroy(codec);
197 
198     format = OH_AVFormat_Create();
199     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
200     result0 = aDecBufferDemo->SetCallback(codec);
201     channel = 9;
202     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
203     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
204     result0 = aDecBufferDemo->Destroy(codec);
205 
206     delete aDecBufferDemo;
207 }
208 
209 /**
210  * @tc.number    : PARAM_CHECK_004
211  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_AAC) param check
212  * @tc.desc      : param check test
213  */
214 HWTEST_F(ParamCheckTest, PARAM_CHECK_004, TestSize.Level2)
215 {
216     OH_AVCodec *codec = nullptr;
217     OH_AVFormat *format = OH_AVFormat_Create();
218     int32_t channel = 2;
219     int32_t sampleRate = 8000;  // 8000hz
220     OH_AVErrCode result0;
221     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
222     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
223     result0 = aDecBufferDemo->SetCallback(codec);
224     sampleRate = 8000;  // 8000hz
225     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
226     ASSERT_EQ(result0, AV_ERR_OK);
227     result0 = aDecBufferDemo->Destroy(codec);
228 
229     format = OH_AVFormat_Create();
230     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
231     result0 = aDecBufferDemo->SetCallback(codec);
232     sampleRate = 11025;
233     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
234     ASSERT_EQ(result0, AV_ERR_OK);
235     result0 = aDecBufferDemo->Destroy(codec);
236 
237     format = OH_AVFormat_Create();
238     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
239     result0 = aDecBufferDemo->SetCallback(codec);
240     sampleRate = 12000;  // 12000hz
241     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
242     ASSERT_EQ(result0, AV_ERR_OK);
243     result0 = aDecBufferDemo->Destroy(codec);
244 
245     format = OH_AVFormat_Create();
246     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
247     result0 = aDecBufferDemo->SetCallback(codec);
248     sampleRate = 16000;  // 16000hz
249     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
250     ASSERT_EQ(result0, AV_ERR_OK);
251     result0 = aDecBufferDemo->Destroy(codec);
252 
253     format = OH_AVFormat_Create();
254     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
255     result0 = aDecBufferDemo->SetCallback(codec);
256     sampleRate = 22050;  // 22050hz
257     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
258     ASSERT_EQ(result0, AV_ERR_OK);
259     result0 = aDecBufferDemo->Destroy(codec);
260 
261     format = OH_AVFormat_Create();
262     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
263     result0 = aDecBufferDemo->SetCallback(codec);
264     sampleRate = 24000;  // 24000hz
265     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
266     ASSERT_EQ(result0, AV_ERR_OK);
267     result0 = aDecBufferDemo->Destroy(codec);
268 
269     format = OH_AVFormat_Create();
270     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
271     result0 = aDecBufferDemo->SetCallback(codec);
272     sampleRate = 32000;  // 32000hz
273     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
274     ASSERT_EQ(result0, AV_ERR_OK);
275     result0 = aDecBufferDemo->Destroy(codec);
276 
277     format = OH_AVFormat_Create();
278     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
279     result0 = aDecBufferDemo->SetCallback(codec);
280     sampleRate = 44100;  // 44100hz
281     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
282     ASSERT_EQ(result0, AV_ERR_OK);
283     result0 = aDecBufferDemo->Destroy(codec);
284 
285     format = OH_AVFormat_Create();
286     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
287     result0 = aDecBufferDemo->SetCallback(codec);
288     sampleRate = 48000;  // 48000hz
289     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
290     ASSERT_EQ(result0, AV_ERR_OK);
291     result0 = aDecBufferDemo->Destroy(codec);
292 
293     format = OH_AVFormat_Create();
294     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
295     result0 = aDecBufferDemo->SetCallback(codec);
296     sampleRate = 64000;  // 64000hz
297     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
298     ASSERT_EQ(result0, AV_ERR_OK);
299     result0 = aDecBufferDemo->Destroy(codec);
300 
301     format = OH_AVFormat_Create();
302     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
303     result0 = aDecBufferDemo->SetCallback(codec);
304     sampleRate = 88200;  // 88200hz
305     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
306     ASSERT_EQ(result0, AV_ERR_OK);
307     result0 = aDecBufferDemo->Destroy(codec);
308 
309     format = OH_AVFormat_Create();
310     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
311     result0 = aDecBufferDemo->SetCallback(codec);
312     sampleRate = 96000;  // 96000hz
313     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
314     ASSERT_EQ(result0, AV_ERR_OK);
315     result0 = aDecBufferDemo->Destroy(codec);
316 
317     format = OH_AVFormat_Create();
318     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
319     result0 = aDecBufferDemo->SetCallback(codec);
320     sampleRate = 7999;  // 7999hz
321     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
322     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
323     result0 = aDecBufferDemo->Destroy(codec);
324 
325     format = OH_AVFormat_Create();
326     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
327     result0 = aDecBufferDemo->SetCallback(codec);
328     sampleRate = 96001;  // 96001hz
329     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
330     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
331     result0 = aDecBufferDemo->Destroy(codec);
332 
333     delete aDecBufferDemo;
334 }
335 
336 /**
337  * @tc.number    : PARAM_CHECK_005
338  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_FLAC) param check
339  * @tc.desc      : param check test
340  */
341 HWTEST_F(ParamCheckTest, PARAM_CHECK_005, TestSize.Level2)
342 {
343     OH_AVCodec *codec = nullptr;
344     OH_AVFormat *format = OH_AVFormat_Create();
345     int32_t channel = 2;
346     int32_t sampleRate = 48000;
347     OH_AVErrCode result0;
348     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
349     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
350     result0 = aDecBufferDemo->SetCallback(codec);
351     channel = 1;
352     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
353     ASSERT_EQ(result0, AV_ERR_OK);
354     result0 = aDecBufferDemo->Destroy(codec);
355 
356     format = OH_AVFormat_Create();
357     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
358     result0 = aDecBufferDemo->SetCallback(codec);
359     channel = 8;
360     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
361     ASSERT_EQ(result0, AV_ERR_OK);
362     result0 = aDecBufferDemo->Destroy(codec);
363 
364     format = OH_AVFormat_Create();
365     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
366     result0 = aDecBufferDemo->SetCallback(codec);
367     channel = 0;
368     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
369     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
370     result0 = aDecBufferDemo->Destroy(codec);
371 
372     format = OH_AVFormat_Create();
373     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
374     result0 = aDecBufferDemo->SetCallback(codec);
375     channel = 9;
376     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
377     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
378     result0 = aDecBufferDemo->Destroy(codec);
379 
380     delete aDecBufferDemo;
381 }
382 
383 /**
384  * @tc.number    : PARAM_CHECK_006
385  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_FLAC) param check
386  * @tc.desc      : param check test
387  */
388 HWTEST_F(ParamCheckTest, PARAM_CHECK_006, TestSize.Level2)
389 {
390     OH_AVCodec *codec = nullptr;
391     OH_AVFormat *format = OH_AVFormat_Create();
392     int32_t channel = 2;         // 2 channel
393     int32_t sampleRate = 8000;  // 8000hz
394     OH_AVErrCode result0;
395     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
396     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
397     result0 = aDecBufferDemo->SetCallback(codec);
398     sampleRate = 8000;  // 8000hz
399     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
400     ASSERT_EQ(result0, AV_ERR_OK);
401     result0 = aDecBufferDemo->Destroy(codec);
402 
403     format = OH_AVFormat_Create();
404     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
405     result0 = aDecBufferDemo->SetCallback(codec);
406     sampleRate = 16000;  // 16000hz
407     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
408     ASSERT_EQ(result0, AV_ERR_OK);
409     result0 = aDecBufferDemo->Destroy(codec);
410 
411     format = OH_AVFormat_Create();
412     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
413     result0 = aDecBufferDemo->SetCallback(codec);
414     sampleRate = 22050;  // 22050hz
415     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
416     ASSERT_EQ(result0, AV_ERR_OK);
417     result0 = aDecBufferDemo->Destroy(codec);
418 
419     format = OH_AVFormat_Create();
420     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
421     result0 = aDecBufferDemo->SetCallback(codec);
422     sampleRate = 24000;  // 24000hz
423     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
424     ASSERT_EQ(result0, AV_ERR_OK);
425     result0 = aDecBufferDemo->Destroy(codec);
426 
427     format = OH_AVFormat_Create();
428     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
429     result0 = aDecBufferDemo->SetCallback(codec);
430     sampleRate = 32000;  // 32000hz
431     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
432     ASSERT_EQ(result0, AV_ERR_OK);
433     result0 = aDecBufferDemo->Destroy(codec);
434 
435     format = OH_AVFormat_Create();
436     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
437     result0 = aDecBufferDemo->SetCallback(codec);
438     sampleRate = 44100;  // 44100hz
439     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
440     ASSERT_EQ(result0, AV_ERR_OK);
441     result0 = aDecBufferDemo->Destroy(codec);
442 
443     format = OH_AVFormat_Create();
444     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
445     result0 = aDecBufferDemo->SetCallback(codec);
446     sampleRate = 48000;  // 48000hz
447     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
448     ASSERT_EQ(result0, AV_ERR_OK);
449     result0 = aDecBufferDemo->Destroy(codec);
450 
451     format = OH_AVFormat_Create();
452     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
453     result0 = aDecBufferDemo->SetCallback(codec);
454     sampleRate = 88200;  // 88200hz
455     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
456     ASSERT_EQ(result0, AV_ERR_OK);
457     result0 = aDecBufferDemo->Destroy(codec);
458 
459     format = OH_AVFormat_Create();
460     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
461     result0 = aDecBufferDemo->SetCallback(codec);
462     sampleRate = 96000;  // 96000hz
463     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
464     ASSERT_EQ(result0, AV_ERR_OK);
465     result0 = aDecBufferDemo->Destroy(codec);
466 
467     format = OH_AVFormat_Create();
468     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
469     result0 = aDecBufferDemo->SetCallback(codec);
470     sampleRate = 96001;  // 96001hz
471     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
472     ASSERT_EQ(result0, AV_ERR_OK);
473     result0 = aDecBufferDemo->Destroy(codec);
474 
475     format = OH_AVFormat_Create();
476     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
477     result0 = aDecBufferDemo->SetCallback(codec);
478     sampleRate = 192000;  // 192000hz
479     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
480     ASSERT_EQ(result0, AV_ERR_OK);
481     result0 = aDecBufferDemo->Destroy(codec);
482 
483     format = OH_AVFormat_Create();
484     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
485     result0 = aDecBufferDemo->SetCallback(codec);
486     sampleRate = 384000;  // 384000hz
487     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
488     ASSERT_EQ(result0, AV_ERR_OK);
489     result0 = aDecBufferDemo->Destroy(codec);
490 
491     delete aDecBufferDemo;
492 }
493 
494 /**
495  * @tc.number    : PARAM_CHECK_007
496  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_MPEG) param check
497  * @tc.desc      : param check test
498  */
499 HWTEST_F(ParamCheckTest, PARAM_CHECK_007, TestSize.Level2)
500 {
501     OH_AVCodec *codec = nullptr;
502     OH_AVFormat *format = OH_AVFormat_Create();
503     int32_t channel = 2;
504     int32_t sampleRate = 48000;
505     OH_AVErrCode result0;
506     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
507     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
508     result0 = aDecBufferDemo->SetCallback(codec);
509     channel = 1;
510     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
511     ASSERT_EQ(result0, AV_ERR_OK);
512     result0 = aDecBufferDemo->Destroy(codec);
513 
514     format = OH_AVFormat_Create();
515     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
516     result0 = aDecBufferDemo->SetCallback(codec);
517     channel = 2;
518     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
519     ASSERT_EQ(result0, AV_ERR_OK);
520     result0 = aDecBufferDemo->Destroy(codec);
521 
522     format = OH_AVFormat_Create();
523     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
524     result0 = aDecBufferDemo->SetCallback(codec);
525     channel = 0;
526     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
527     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
528     result0 = aDecBufferDemo->Destroy(codec);
529 
530     format = OH_AVFormat_Create();
531     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
532     result0 = aDecBufferDemo->SetCallback(codec);
533     channel = 9;
534     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
535     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
536     result0 = aDecBufferDemo->Destroy(codec);
537 
538     delete aDecBufferDemo;
539 }
540 
541 /**
542  * @tc.number    : PARAM_CHECK_008
543  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_MPEG) param check
544  * @tc.desc      : param check test
545  */
546 HWTEST_F(ParamCheckTest, PARAM_CHECK_008, TestSize.Level2)
547 {
548     OH_AVCodec *codec = nullptr;
549     OH_AVFormat *format = OH_AVFormat_Create();
550     int32_t channel = 2;         // 2 chan
551     int32_t sampleRate = 8000;  // 8000hz
552     OH_AVErrCode result0;
553     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
554     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
555     result0 = aDecBufferDemo->SetCallback(codec);
556     sampleRate = 8000;  // 8000hz
557     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
558     ASSERT_EQ(result0, AV_ERR_OK);
559     result0 = aDecBufferDemo->Destroy(codec);
560 
561     format = OH_AVFormat_Create();
562     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
563     result0 = aDecBufferDemo->SetCallback(codec);
564     sampleRate = 11025;  // 11025hz
565     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
566     ASSERT_EQ(result0, AV_ERR_OK);
567     result0 = aDecBufferDemo->Destroy(codec);
568 
569     format = OH_AVFormat_Create();
570     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
571     result0 = aDecBufferDemo->SetCallback(codec);
572     sampleRate = 12000;  // 12000hz
573     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
574     ASSERT_EQ(result0, AV_ERR_OK);
575     result0 = aDecBufferDemo->Destroy(codec);
576 
577     format = OH_AVFormat_Create();
578     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
579     result0 = aDecBufferDemo->SetCallback(codec);
580     sampleRate = 16000;  // 16000hz
581     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
582     ASSERT_EQ(result0, AV_ERR_OK);
583     result0 = aDecBufferDemo->Destroy(codec);
584 
585     format = OH_AVFormat_Create();
586     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
587     result0 = aDecBufferDemo->SetCallback(codec);
588     sampleRate = 22050;  // 22050hz
589     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
590     ASSERT_EQ(result0, AV_ERR_OK);
591     result0 = aDecBufferDemo->Destroy(codec);
592 
593     format = OH_AVFormat_Create();
594     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
595     result0 = aDecBufferDemo->SetCallback(codec);
596     sampleRate = 24000;  // 24000hz
597     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
598     ASSERT_EQ(result0, AV_ERR_OK);
599     result0 = aDecBufferDemo->Destroy(codec);
600 
601     format = OH_AVFormat_Create();
602     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
603     result0 = aDecBufferDemo->SetCallback(codec);
604     sampleRate = 32000;  // 32000hz
605     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
606     ASSERT_EQ(result0, AV_ERR_OK);
607     result0 = aDecBufferDemo->Destroy(codec);
608 
609     format = OH_AVFormat_Create();
610     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
611     result0 = aDecBufferDemo->SetCallback(codec);
612     sampleRate = 44100;  // 44100hz
613     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
614     ASSERT_EQ(result0, AV_ERR_OK);
615     result0 = aDecBufferDemo->Destroy(codec);
616 
617     format = OH_AVFormat_Create();
618     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
619     result0 = aDecBufferDemo->SetCallback(codec);
620     sampleRate = 48000;  // 48000hz
621     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
622     ASSERT_EQ(result0, AV_ERR_OK);
623     result0 = aDecBufferDemo->Destroy(codec);
624 
625     format = OH_AVFormat_Create();
626     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
627     result0 = aDecBufferDemo->SetCallback(codec);
628     sampleRate = 7999;  // 7999hz
629     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
630     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
631     result0 = aDecBufferDemo->Destroy(codec);
632 
633     format = OH_AVFormat_Create();
634     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
635     result0 = aDecBufferDemo->SetCallback(codec);
636     sampleRate = 48001;  // 48001hz
637     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
638     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
639     result0 = aDecBufferDemo->Destroy(codec);
640 
641     delete aDecBufferDemo;
642 }
643 
644 /**
645  * @tc.number    : PARAM_CHECK_011
646  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB) param check
647  * @tc.desc      : param check test
648  */
649 HWTEST_F(ParamCheckTest, PARAM_CHECK_011, TestSize.Level2)
650 {
651     OH_AVCodec *codec = nullptr;
652     OH_AVFormat *format = OH_AVFormat_Create();
653     int32_t channel = 1;
654     int32_t sampleRate = 8000;  // 8000hz
655     OH_AVErrCode result0;
656     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
657     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
658     result0 = aDecBufferDemo->SetCallback(codec);
659     channel = 1;
660     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
661     ASSERT_EQ(result0, AV_ERR_OK);
662     result0 = aDecBufferDemo->Destroy(codec);
663 
664     format = OH_AVFormat_Create();
665     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
666     result0 = aDecBufferDemo->SetCallback(codec);
667     channel = 0;
668     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
669     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
670     result0 = aDecBufferDemo->Destroy(codec);
671 
672     format = OH_AVFormat_Create();
673     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
674     result0 = aDecBufferDemo->SetCallback(codec);
675     channel = 2;  // 2 channel
676     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
677     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
678     result0 = aDecBufferDemo->Destroy(codec);
679 
680     delete aDecBufferDemo;
681 }
682 
683 /**
684  * @tc.number    : PARAM_CHECK_012
685  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB) param check
686  * @tc.desc      : param check test
687  */
688 HWTEST_F(ParamCheckTest, PARAM_CHECK_012, TestSize.Level2)
689 {
690     OH_AVCodec *codec = nullptr;
691     OH_AVFormat *format = OH_AVFormat_Create();
692     int32_t channel = 1;
693     int32_t sampleRate = 8000;  // 8000hz
694     OH_AVErrCode result0;
695     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
696     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
697     result0 = aDecBufferDemo->SetCallback(codec);
698     sampleRate = 8000;  // 8000hz
699     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
700     ASSERT_EQ(result0, AV_ERR_OK);
701     result0 = aDecBufferDemo->Destroy(codec);
702 
703     format = OH_AVFormat_Create();
704     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
705     result0 = aDecBufferDemo->SetCallback(codec);
706     sampleRate = 7999;  // 7999hz
707     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
708     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
709     result0 = aDecBufferDemo->Destroy(codec);
710 
711     format = OH_AVFormat_Create();
712     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
713     result0 = aDecBufferDemo->SetCallback(codec);
714     sampleRate = 8001;  // 8001hz
715     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
716     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
717     result0 = aDecBufferDemo->Destroy(codec);
718 
719     delete aDecBufferDemo;
720 }
721 
722 /**
723  * @tc.number    : PARAM_CHECK_013
724  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB) param check
725  * @tc.desc      : param check test
726  */
727 HWTEST_F(ParamCheckTest, PARAM_CHECK_013, TestSize.Level2)
728 {
729     OH_AVCodec *codec = nullptr;
730     OH_AVFormat *format = OH_AVFormat_Create();
731     int32_t channel = 1;
732     int32_t sampleRate = 16000;  // 16000hz
733     OH_AVErrCode result0;
734     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
735     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
736     result0 = aDecBufferDemo->SetCallback(codec);
737     channel = 1;
738     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
739     ASSERT_EQ(result0, AV_ERR_OK);
740     result0 = aDecBufferDemo->Destroy(codec);
741 
742     format = OH_AVFormat_Create();
743     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
744     result0 = aDecBufferDemo->SetCallback(codec);
745     channel = 0;
746     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
747     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
748     result0 = aDecBufferDemo->Destroy(codec);
749 
750     format = OH_AVFormat_Create();
751     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
752     result0 = aDecBufferDemo->SetCallback(codec);
753     channel = 2;  // 2 channel
754     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
755     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
756     result0 = aDecBufferDemo->Destroy(codec);
757 
758     delete aDecBufferDemo;
759 }
760 
761 /**
762  * @tc.number    : PARAM_CHECK_014
763  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB) param check
764  * @tc.desc      : param check test
765  */
766 HWTEST_F(ParamCheckTest, PARAM_CHECK_014, TestSize.Level2)
767 {
768     OH_AVCodec *codec = nullptr;
769     OH_AVFormat *format = OH_AVFormat_Create();
770     int32_t channel = 1;
771     int32_t sampleRate = 16000;  // 16000hz
772     OH_AVErrCode result0;
773     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
774     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
775     result0 = aDecBufferDemo->SetCallback(codec);
776     sampleRate = 16000;  // 16000hz
777     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
778     ASSERT_EQ(result0, AV_ERR_OK);
779     result0 = aDecBufferDemo->Destroy(codec);
780 
781     format = OH_AVFormat_Create();
782     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
783     result0 = aDecBufferDemo->SetCallback(codec);
784     sampleRate = 15999;  // 15999hz
785     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
786     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
787     result0 = aDecBufferDemo->Destroy(codec);
788 
789     format = OH_AVFormat_Create();
790     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
791     result0 = aDecBufferDemo->SetCallback(codec);
792     sampleRate = 16001;  // 16001hz
793     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
794     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
795     result0 = aDecBufferDemo->Destroy(codec);
796 
797     delete aDecBufferDemo;
798 }
799 
800 /**
801  * @tc.number    : PARAM_CHECK_016
802  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_G711MU) param check
803  * @tc.desc      : param check test
804  */
805 HWTEST_F(ParamCheckTest, PARAM_CHECK_016, TestSize.Level2)
806 {
807     OH_AVCodec *codec = nullptr;
808     OH_AVFormat *format = OH_AVFormat_Create();
809     int32_t channel = 1;
810     int32_t sampleRate = 8000;  // 8000hz
811     OH_AVErrCode result0;
812     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
813     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
814     result0 = aDecBufferDemo->SetCallback(codec);
815     channel = 1;
816     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
817     ASSERT_EQ(result0, AV_ERR_OK);
818     result0 = aDecBufferDemo->Destroy(codec);
819 
820     format = OH_AVFormat_Create();
821     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
822     result0 = aDecBufferDemo->SetCallback(codec);
823     channel = 0;
824     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
825     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
826     result0 = aDecBufferDemo->Destroy(codec);
827 
828     format = OH_AVFormat_Create();
829     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
830     result0 = aDecBufferDemo->SetCallback(codec);
831     channel = 2;  // 2 channel
832     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
833     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
834     result0 = aDecBufferDemo->Destroy(codec);
835 
836     delete aDecBufferDemo;
837 }
838 
839 /**
840  * @tc.number    : PARAM_CHECK_017
841  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_G711MU) param check
842  * @tc.desc      : param check test
843  */
844 HWTEST_F(ParamCheckTest, PARAM_CHECK_017, TestSize.Level2)
845 {
846     OH_AVCodec *codec = nullptr;
847     OH_AVFormat *format = OH_AVFormat_Create();
848     int32_t channel = 1;
849     int32_t sampleRate = 8000;  // 8000hz
850     OH_AVErrCode result0;
851     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
852     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
853     result0 = aDecBufferDemo->SetCallback(codec);
854     sampleRate = 8000;  // 8000hz
855     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
856     ASSERT_EQ(result0, AV_ERR_OK);
857     result0 = aDecBufferDemo->Destroy(codec);
858 
859     format = OH_AVFormat_Create();
860     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
861     result0 = aDecBufferDemo->SetCallback(codec);
862     sampleRate = 7999;  // 7999hz
863     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
864     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
865     result0 = aDecBufferDemo->Destroy(codec);
866 
867     format = OH_AVFormat_Create();
868     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
869     result0 = aDecBufferDemo->SetCallback(codec);
870     sampleRate = 8001;  // 8001hz
871     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
872     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
873     result0 = aDecBufferDemo->Destroy(codec);
874 
875     delete aDecBufferDemo;
876 }
877 
878 /**
879  * @tc.number    : PARAM_CHECK_021
880  * @tc.name      : FreeOutputData - index param check
881  * @tc.desc      : param check test
882  */
883 HWTEST_F(ParamCheckTest, PARAM_CHECK_021, TestSize.Level2)
884 {
885     OH_AVCodec *codec = nullptr;
886     OH_AVFormat *format = OH_AVFormat_Create();
887     int32_t channel = 1;
888     int32_t sampleRate = 8000;  // 8000hz
889     uint32_t index;
890     OH_AVErrCode result0;
891     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
892     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
893     ASSERT_NE(codec, nullptr);
894     result0 = aDecBufferDemo->SetCallback(codec);
895     ASSERT_EQ(result0, AV_ERR_OK);
896     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
897     ASSERT_EQ(result0, AV_ERR_OK);
898     result0 = aDecBufferDemo->Start(codec);
899     ASSERT_EQ(result0, AV_ERR_OK);
900     index = aDecBufferDemo->GetInputIndex();
901     index = 8;
902     result0 = aDecBufferDemo->PushInputData(codec, index);
903     ASSERT_NE(result0, AV_ERR_OK);
904     index = aDecBufferDemo->GetOutputIndex();
905     index = -1;
906     result0 = aDecBufferDemo->FreeOutputData(codec, index);
907     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
908     result0 = aDecBufferDemo->Destroy(codec);
909 
910     delete aDecBufferDemo;
911 }
912 
913 /**
914  * @tc.number    : PARAM_CHECK_022
915  * @tc.name      : PushInputDataEOS - index param check
916  * @tc.desc      : param check test
917  */
918 HWTEST_F(ParamCheckTest, PARAM_CHECK_022, TestSize.Level2)
919 {
920     OH_AVCodec *codec = nullptr;
921     OH_AVFormat *format = OH_AVFormat_Create();
922     int32_t channel = 1;
923     int32_t sampleRate = 8000;  // 8000hz
924     uint32_t index;
925     OH_AVErrCode result0;
926     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
927     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
928     ASSERT_NE(codec, nullptr);
929     result0 = aDecBufferDemo->SetCallback(codec);
930     ASSERT_EQ(result0, AV_ERR_OK);
931     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
932     ASSERT_EQ(result0, AV_ERR_OK);
933     result0 = aDecBufferDemo->Start(codec);
934     ASSERT_EQ(result0, AV_ERR_OK);
935     index = aDecBufferDemo->GetInputIndex();
936     index = -1;
937     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
938     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
939     result0 = aDecBufferDemo->Destroy(codec);
940 
941     format = OH_AVFormat_Create();
942     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
943     ASSERT_NE(codec, nullptr);
944     result0 = aDecBufferDemo->SetCallback(codec);
945     ASSERT_EQ(result0, AV_ERR_OK);
946     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
947     ASSERT_EQ(result0, AV_ERR_OK);
948     result0 = aDecBufferDemo->Start(codec);
949     ASSERT_EQ(result0, AV_ERR_OK);
950     index = aDecBufferDemo->GetInputIndex();
951     index = 8;
952     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
953     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
954     result0 = aDecBufferDemo->Destroy(codec);
955 
956     delete aDecBufferDemo;
957 }
958 
959 /**
960  * @tc.number    : PARAM_CHECK_023
961  * @tc.name      : PARAM_CHECK_023
962  * @tc.desc      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_G711A) param check test
963  */
964 HWTEST_F(ParamCheckTest, PARAM_CHECK_023, TestSize.Level2)
965 {
966     OH_AVCodec *codec = nullptr;
967     OH_AVFormat *format = OH_AVFormat_Create();
968     int32_t channel = 1;
969     int32_t sampleRate = 8000;  // 8000hz
970     OH_AVErrCode result0;
971     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
972     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711A);
973     result0 = aDecBufferDemo->SetCallback(codec);
974     channel = 1;
975     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
976     ASSERT_EQ(result0, AV_ERR_OK);
977     result0 = aDecBufferDemo->Destroy(codec);
978     OH_AVFormat_Destroy(format);
979 
980     format = OH_AVFormat_Create();
981     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711A);
982     result0 = aDecBufferDemo->SetCallback(codec);
983     channel = 0;
984     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
985     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
986     result0 = aDecBufferDemo->Destroy(codec);
987     OH_AVFormat_Destroy(format);
988 
989     format = OH_AVFormat_Create();
990     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711A);
991     result0 = aDecBufferDemo->SetCallback(codec);
992     channel = 7;  // 7 channel
993     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
994     ASSERT_EQ(result0, AV_ERR_OK);
995     result0 = aDecBufferDemo->Destroy(codec);
996     OH_AVFormat_Destroy(format);
997     format = nullptr;
998 
999     delete aDecBufferDemo;
1000 }
1001 
1002 /**
1003  * @tc.number    : PARAM_CHECK_024
1004  * @tc.name      : PARAM_CHECK_024
1005  * @tc.desc      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_G711A) param check test
1006  */
1007 HWTEST_F(ParamCheckTest, PARAM_CHECK_024, TestSize.Level2)
1008 {
1009     OH_AVCodec *codec = nullptr;
1010     OH_AVFormat *format = OH_AVFormat_Create();
1011     int32_t channel = 1;
1012     int32_t sampleRate = 8000;  // 8000hz
1013     OH_AVErrCode result0;
1014     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1015     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711A);
1016     result0 = aDecBufferDemo->SetCallback(codec);
1017     sampleRate = 8000;  // 8000hz
1018     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1019     ASSERT_EQ(result0, AV_ERR_OK);
1020     result0 = aDecBufferDemo->Destroy(codec);
1021     OH_AVFormat_Destroy(format);
1022 
1023     format = OH_AVFormat_Create();
1024     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711A);
1025     result0 = aDecBufferDemo->SetCallback(codec);
1026     sampleRate = 16000;  // 16000hz
1027     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1028     ASSERT_EQ(result0, AV_ERR_OK);
1029     result0 = aDecBufferDemo->Destroy(codec);
1030     OH_AVFormat_Destroy(format);
1031 
1032     format = OH_AVFormat_Create();
1033     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711A);
1034     result0 = aDecBufferDemo->SetCallback(codec);
1035     sampleRate = 44100;  // 44100hz
1036     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1037     ASSERT_EQ(result0, AV_ERR_OK);
1038     result0 = aDecBufferDemo->Destroy(codec);
1039     OH_AVFormat_Destroy(format);
1040 
1041     format = OH_AVFormat_Create();
1042     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711A);
1043     result0 = aDecBufferDemo->SetCallback(codec);
1044     sampleRate = 48000;  // 48000hz
1045     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1046     ASSERT_EQ(result0, AV_ERR_OK);
1047     result0 = aDecBufferDemo->Destroy(codec);
1048     OH_AVFormat_Destroy(format);
1049     format = nullptr;
1050 
1051     delete aDecBufferDemo;
1052 }