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  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_001, TestSize.Level2)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("aaa");
92     ASSERT_EQ(codec, nullptr);
93     result0 = aDecBufferDemo->Destroy(codec);
94     ASSERT_NE(result0, AV_ERR_OK);
95 
96     delete aDecBufferDemo;
97 }
98 
99 /**
100  * @tc.number    : PARAM_CHECK_002
101  * @tc.name      : CreateByName - mime param check
102  * @tc.desc      : param check test
103  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_002, TestSize.Level2)104 HWTEST_F(ParamCheckTest, PARAM_CHECK_002, TestSize.Level2)
105 {
106     OH_AVCodec *codec = nullptr;
107     OH_AVErrCode result0;
108     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
109     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.AAC");
110     ASSERT_NE(codec, nullptr);
111     result0 = aDecBufferDemo->Destroy(codec);
112     ASSERT_EQ(result0, AV_ERR_OK);
113 
114     codec = aDecBufferDemo->CreateByName("OH.Media.Codec.Decoder.Audio.Flac");
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.Mpeg");
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.Vorbis");
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.Amrnb");
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.Amrwb");
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.G711mu");
140     ASSERT_NE(codec, nullptr);
141     result0 = aDecBufferDemo->Destroy(codec);
142     ASSERT_EQ(result0, AV_ERR_OK);
143 
144     codec = aDecBufferDemo->CreateByName("aaa");
145     ASSERT_EQ(codec, nullptr);
146     result0 = aDecBufferDemo->Destroy(codec);
147     ASSERT_NE(result0, AV_ERR_OK);
148 
149     delete aDecBufferDemo;
150 }
151 
152 /**
153  * @tc.number    : PARAM_CHECK_003
154  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_AAC) param check
155  * @tc.desc      : param check test
156  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_003, TestSize.Level2)157 HWTEST_F(ParamCheckTest, PARAM_CHECK_003, TestSize.Level2)
158 {
159     OH_AVCodec *codec = nullptr;
160     OH_AVFormat *format = OH_AVFormat_Create();
161     int32_t channel = 2;
162     int32_t sampleRate = 48000;
163     OH_AVErrCode result0;
164     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
165     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
166     result0 = aDecBufferDemo->SetCallback(codec);
167     channel = 1;
168     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
169     ASSERT_EQ(result0, AV_ERR_OK);
170     result0 = aDecBufferDemo->Destroy(codec);
171 
172     format = OH_AVFormat_Create();
173     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
174     result0 = aDecBufferDemo->SetCallback(codec);
175     channel = 8;
176     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
177     ASSERT_EQ(result0, AV_ERR_OK);
178     result0 = aDecBufferDemo->Destroy(codec);
179 
180     format = OH_AVFormat_Create();
181     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
182     result0 = aDecBufferDemo->SetCallback(codec);
183     channel = 0;
184     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
185     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
186     result0 = aDecBufferDemo->Destroy(codec);
187 
188     format = OH_AVFormat_Create();
189     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
190     result0 = aDecBufferDemo->SetCallback(codec);
191     channel = 9;
192     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
193     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
194     result0 = aDecBufferDemo->Destroy(codec);
195 
196     delete aDecBufferDemo;
197 }
198 
199 /**
200  * @tc.number    : PARAM_CHECK_004
201  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_AAC) param check
202  * @tc.desc      : param check test
203  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_004, TestSize.Level2)204 HWTEST_F(ParamCheckTest, PARAM_CHECK_004, TestSize.Level2)
205 {
206     OH_AVCodec *codec = nullptr;
207     OH_AVFormat *format = OH_AVFormat_Create();
208     int32_t channel = 2;
209     int32_t sampleRate = 8000;  // 8000hz
210     OH_AVErrCode result0;
211     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
212     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
213     result0 = aDecBufferDemo->SetCallback(codec);
214     sampleRate = 8000;  // 8000hz
215     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
216     ASSERT_EQ(result0, AV_ERR_OK);
217     result0 = aDecBufferDemo->Destroy(codec);
218 
219     format = OH_AVFormat_Create();
220     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
221     result0 = aDecBufferDemo->SetCallback(codec);
222     sampleRate = 11025;
223     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
224     ASSERT_EQ(result0, AV_ERR_OK);
225     result0 = aDecBufferDemo->Destroy(codec);
226 
227     format = OH_AVFormat_Create();
228     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
229     result0 = aDecBufferDemo->SetCallback(codec);
230     sampleRate = 12000;  // 12000hz
231     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
232     ASSERT_EQ(result0, AV_ERR_OK);
233     result0 = aDecBufferDemo->Destroy(codec);
234 
235     format = OH_AVFormat_Create();
236     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
237     result0 = aDecBufferDemo->SetCallback(codec);
238     sampleRate = 16000;  // 16000hz
239     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
240     ASSERT_EQ(result0, AV_ERR_OK);
241     result0 = aDecBufferDemo->Destroy(codec);
242 
243     format = OH_AVFormat_Create();
244     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
245     result0 = aDecBufferDemo->SetCallback(codec);
246     sampleRate = 22050;  // 22050hz
247     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
248     ASSERT_EQ(result0, AV_ERR_OK);
249     result0 = aDecBufferDemo->Destroy(codec);
250 
251     format = OH_AVFormat_Create();
252     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
253     result0 = aDecBufferDemo->SetCallback(codec);
254     sampleRate = 24000;  // 24000hz
255     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
256     ASSERT_EQ(result0, AV_ERR_OK);
257     result0 = aDecBufferDemo->Destroy(codec);
258 
259     format = OH_AVFormat_Create();
260     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
261     result0 = aDecBufferDemo->SetCallback(codec);
262     sampleRate = 32000;  // 32000hz
263     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
264     ASSERT_EQ(result0, AV_ERR_OK);
265     result0 = aDecBufferDemo->Destroy(codec);
266 
267     format = OH_AVFormat_Create();
268     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
269     result0 = aDecBufferDemo->SetCallback(codec);
270     sampleRate = 44100;  // 44100hz
271     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
272     ASSERT_EQ(result0, AV_ERR_OK);
273     result0 = aDecBufferDemo->Destroy(codec);
274 
275     format = OH_AVFormat_Create();
276     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
277     result0 = aDecBufferDemo->SetCallback(codec);
278     sampleRate = 48000;  // 48000hz
279     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
280     ASSERT_EQ(result0, AV_ERR_OK);
281     result0 = aDecBufferDemo->Destroy(codec);
282 
283     format = OH_AVFormat_Create();
284     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
285     result0 = aDecBufferDemo->SetCallback(codec);
286     sampleRate = 64000;  // 64000hz
287     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
288     ASSERT_EQ(result0, AV_ERR_OK);
289     result0 = aDecBufferDemo->Destroy(codec);
290 
291     format = OH_AVFormat_Create();
292     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
293     result0 = aDecBufferDemo->SetCallback(codec);
294     sampleRate = 88200;  // 88200hz
295     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
296     ASSERT_EQ(result0, AV_ERR_OK);
297     result0 = aDecBufferDemo->Destroy(codec);
298 
299     format = OH_AVFormat_Create();
300     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
301     result0 = aDecBufferDemo->SetCallback(codec);
302     sampleRate = 96000;  // 96000hz
303     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
304     ASSERT_EQ(result0, AV_ERR_OK);
305     result0 = aDecBufferDemo->Destroy(codec);
306 
307     format = OH_AVFormat_Create();
308     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
309     result0 = aDecBufferDemo->SetCallback(codec);
310     sampleRate = 7999;  // 7999hz
311     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
312     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
313     result0 = aDecBufferDemo->Destroy(codec);
314 
315     format = OH_AVFormat_Create();
316     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
317     result0 = aDecBufferDemo->SetCallback(codec);
318     sampleRate = 96001;  // 96001hz
319     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
320     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
321     result0 = aDecBufferDemo->Destroy(codec);
322 
323     delete aDecBufferDemo;
324 }
325 
326 /**
327  * @tc.number    : PARAM_CHECK_005
328  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_FLAC) param check
329  * @tc.desc      : param check test
330  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_005, TestSize.Level2)331 HWTEST_F(ParamCheckTest, PARAM_CHECK_005, TestSize.Level2)
332 {
333     OH_AVCodec *codec = nullptr;
334     OH_AVFormat *format = OH_AVFormat_Create();
335     int32_t channel = 2;
336     int32_t sampleRate = 48000;
337     OH_AVErrCode result0;
338     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
339     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
340     result0 = aDecBufferDemo->SetCallback(codec);
341     channel = 1;
342     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
343     ASSERT_EQ(result0, AV_ERR_OK);
344     result0 = aDecBufferDemo->Destroy(codec);
345 
346     format = OH_AVFormat_Create();
347     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
348     result0 = aDecBufferDemo->SetCallback(codec);
349     channel = 8;
350     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
351     ASSERT_EQ(result0, AV_ERR_OK);
352     result0 = aDecBufferDemo->Destroy(codec);
353 
354     format = OH_AVFormat_Create();
355     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
356     result0 = aDecBufferDemo->SetCallback(codec);
357     channel = 0;
358     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
359     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
360     result0 = aDecBufferDemo->Destroy(codec);
361 
362     format = OH_AVFormat_Create();
363     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
364     result0 = aDecBufferDemo->SetCallback(codec);
365     channel = 9;
366     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
367     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
368     result0 = aDecBufferDemo->Destroy(codec);
369 
370     delete aDecBufferDemo;
371 }
372 
373 /**
374  * @tc.number    : PARAM_CHECK_006
375  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_FLAC) param check
376  * @tc.desc      : param check test
377  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_006, TestSize.Level2)378 HWTEST_F(ParamCheckTest, PARAM_CHECK_006, TestSize.Level2)
379 {
380     OH_AVCodec *codec = nullptr;
381     OH_AVFormat *format = OH_AVFormat_Create();
382     int32_t channel = 2;         // 2 channel
383     int32_t sampleRate = 8000;  // 8000hz
384     OH_AVErrCode result0;
385     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
386     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
387     result0 = aDecBufferDemo->SetCallback(codec);
388     sampleRate = 8000;  // 8000hz
389     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
390     ASSERT_EQ(result0, AV_ERR_OK);
391     result0 = aDecBufferDemo->Destroy(codec);
392 
393     format = OH_AVFormat_Create();
394     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
395     result0 = aDecBufferDemo->SetCallback(codec);
396     sampleRate = 16000;  // 16000hz
397     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
398     ASSERT_EQ(result0, AV_ERR_OK);
399     result0 = aDecBufferDemo->Destroy(codec);
400 
401     format = OH_AVFormat_Create();
402     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
403     result0 = aDecBufferDemo->SetCallback(codec);
404     sampleRate = 22050;  // 22050hz
405     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
406     ASSERT_EQ(result0, AV_ERR_OK);
407     result0 = aDecBufferDemo->Destroy(codec);
408 
409     format = OH_AVFormat_Create();
410     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
411     result0 = aDecBufferDemo->SetCallback(codec);
412     sampleRate = 24000;  // 24000hz
413     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
414     ASSERT_EQ(result0, AV_ERR_OK);
415     result0 = aDecBufferDemo->Destroy(codec);
416 
417     format = OH_AVFormat_Create();
418     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
419     result0 = aDecBufferDemo->SetCallback(codec);
420     sampleRate = 32000;  // 32000hz
421     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
422     ASSERT_EQ(result0, AV_ERR_OK);
423     result0 = aDecBufferDemo->Destroy(codec);
424 
425     format = OH_AVFormat_Create();
426     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
427     result0 = aDecBufferDemo->SetCallback(codec);
428     sampleRate = 44100;  // 44100hz
429     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
430     ASSERT_EQ(result0, AV_ERR_OK);
431     result0 = aDecBufferDemo->Destroy(codec);
432 
433     format = OH_AVFormat_Create();
434     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
435     result0 = aDecBufferDemo->SetCallback(codec);
436     sampleRate = 48000;  // 48000hz
437     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
438     ASSERT_EQ(result0, AV_ERR_OK);
439     result0 = aDecBufferDemo->Destroy(codec);
440 
441     format = OH_AVFormat_Create();
442     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
443     result0 = aDecBufferDemo->SetCallback(codec);
444     sampleRate = 88200;  // 88200hz
445     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
446     ASSERT_EQ(result0, AV_ERR_OK);
447     result0 = aDecBufferDemo->Destroy(codec);
448 
449     format = OH_AVFormat_Create();
450     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
451     result0 = aDecBufferDemo->SetCallback(codec);
452     sampleRate = 96000;  // 96000hz
453     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
454     ASSERT_EQ(result0, AV_ERR_OK);
455     result0 = aDecBufferDemo->Destroy(codec);
456 
457     format = OH_AVFormat_Create();
458     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
459     result0 = aDecBufferDemo->SetCallback(codec);
460     sampleRate = 7999;  // 7999hz
461     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
462     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
463     result0 = aDecBufferDemo->Destroy(codec);
464 
465     format = OH_AVFormat_Create();
466     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
467     result0 = aDecBufferDemo->SetCallback(codec);
468     sampleRate = 96001;  // 48000hz
469     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
470     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
471     result0 = aDecBufferDemo->Destroy(codec);
472 
473     delete aDecBufferDemo;
474 }
475 
476 /**
477  * @tc.number    : PARAM_CHECK_007
478  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_MPEG) param check
479  * @tc.desc      : param check test
480  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_007, TestSize.Level2)481 HWTEST_F(ParamCheckTest, PARAM_CHECK_007, TestSize.Level2)
482 {
483     OH_AVCodec *codec = nullptr;
484     OH_AVFormat *format = OH_AVFormat_Create();
485     int32_t channel = 2;
486     int32_t sampleRate = 48000;
487     OH_AVErrCode result0;
488     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
489     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
490     result0 = aDecBufferDemo->SetCallback(codec);
491     channel = 1;
492     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
493     ASSERT_EQ(result0, AV_ERR_OK);
494     result0 = aDecBufferDemo->Destroy(codec);
495 
496     format = OH_AVFormat_Create();
497     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
498     result0 = aDecBufferDemo->SetCallback(codec);
499     channel = 2;
500     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
501     ASSERT_EQ(result0, AV_ERR_OK);
502     result0 = aDecBufferDemo->Destroy(codec);
503 
504     format = OH_AVFormat_Create();
505     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
506     result0 = aDecBufferDemo->SetCallback(codec);
507     channel = 0;
508     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
509     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
510     result0 = aDecBufferDemo->Destroy(codec);
511 
512     format = OH_AVFormat_Create();
513     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
514     result0 = aDecBufferDemo->SetCallback(codec);
515     channel = 9;
516     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
517     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
518     result0 = aDecBufferDemo->Destroy(codec);
519 
520     delete aDecBufferDemo;
521 }
522 
523 /**
524  * @tc.number    : PARAM_CHECK_008
525  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_MPEG) param check
526  * @tc.desc      : param check test
527  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_008, TestSize.Level2)528 HWTEST_F(ParamCheckTest, PARAM_CHECK_008, TestSize.Level2)
529 {
530     OH_AVCodec *codec = nullptr;
531     OH_AVFormat *format = OH_AVFormat_Create();
532     int32_t channel = 2;         // 2 chan
533     int32_t sampleRate = 8000;  // 8000hz
534     OH_AVErrCode result0;
535     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
536     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
537     result0 = aDecBufferDemo->SetCallback(codec);
538     sampleRate = 8000;  // 8000hz
539     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
540     ASSERT_EQ(result0, AV_ERR_OK);
541     result0 = aDecBufferDemo->Destroy(codec);
542 
543     format = OH_AVFormat_Create();
544     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
545     result0 = aDecBufferDemo->SetCallback(codec);
546     sampleRate = 11025;  // 11025hz
547     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
548     ASSERT_EQ(result0, AV_ERR_OK);
549     result0 = aDecBufferDemo->Destroy(codec);
550 
551     format = OH_AVFormat_Create();
552     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
553     result0 = aDecBufferDemo->SetCallback(codec);
554     sampleRate = 12000;  // 12000hz
555     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
556     ASSERT_EQ(result0, AV_ERR_OK);
557     result0 = aDecBufferDemo->Destroy(codec);
558 
559     format = OH_AVFormat_Create();
560     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
561     result0 = aDecBufferDemo->SetCallback(codec);
562     sampleRate = 16000;  // 16000hz
563     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
564     ASSERT_EQ(result0, AV_ERR_OK);
565     result0 = aDecBufferDemo->Destroy(codec);
566 
567     format = OH_AVFormat_Create();
568     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
569     result0 = aDecBufferDemo->SetCallback(codec);
570     sampleRate = 22050;  // 22050hz
571     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
572     ASSERT_EQ(result0, AV_ERR_OK);
573     result0 = aDecBufferDemo->Destroy(codec);
574 
575     format = OH_AVFormat_Create();
576     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
577     result0 = aDecBufferDemo->SetCallback(codec);
578     sampleRate = 24000;  // 24000hz
579     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
580     ASSERT_EQ(result0, AV_ERR_OK);
581     result0 = aDecBufferDemo->Destroy(codec);
582 
583     format = OH_AVFormat_Create();
584     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
585     result0 = aDecBufferDemo->SetCallback(codec);
586     sampleRate = 32000;  // 32000hz
587     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
588     ASSERT_EQ(result0, AV_ERR_OK);
589     result0 = aDecBufferDemo->Destroy(codec);
590 
591     format = OH_AVFormat_Create();
592     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
593     result0 = aDecBufferDemo->SetCallback(codec);
594     sampleRate = 44100;  // 44100hz
595     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
596     ASSERT_EQ(result0, AV_ERR_OK);
597     result0 = aDecBufferDemo->Destroy(codec);
598 
599     format = OH_AVFormat_Create();
600     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
601     result0 = aDecBufferDemo->SetCallback(codec);
602     sampleRate = 48000;  // 48000hz
603     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
604     ASSERT_EQ(result0, AV_ERR_OK);
605     result0 = aDecBufferDemo->Destroy(codec);
606 
607     format = OH_AVFormat_Create();
608     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
609     result0 = aDecBufferDemo->SetCallback(codec);
610     sampleRate = 7999;  // 7999hz
611     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
612     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
613     result0 = aDecBufferDemo->Destroy(codec);
614 
615     format = OH_AVFormat_Create();
616     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
617     result0 = aDecBufferDemo->SetCallback(codec);
618     sampleRate = 48001;  // 48001hz
619     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
620     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
621     result0 = aDecBufferDemo->Destroy(codec);
622 
623     delete aDecBufferDemo;
624 }
625 
626 /**
627  * @tc.number    : PARAM_CHECK_011
628  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB) param check
629  * @tc.desc      : param check test
630  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_011, TestSize.Level2)631 HWTEST_F(ParamCheckTest, PARAM_CHECK_011, TestSize.Level2)
632 {
633     OH_AVCodec *codec = nullptr;
634     OH_AVFormat *format = OH_AVFormat_Create();
635     int32_t channel = 1;
636     int32_t sampleRate = 8000;  // 8000hz
637     OH_AVErrCode result0;
638     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
639     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
640     result0 = aDecBufferDemo->SetCallback(codec);
641     channel = 1;
642     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
643     ASSERT_EQ(result0, AV_ERR_OK);
644     result0 = aDecBufferDemo->Destroy(codec);
645 
646     format = OH_AVFormat_Create();
647     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
648     result0 = aDecBufferDemo->SetCallback(codec);
649     channel = 0;
650     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
651     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
652     result0 = aDecBufferDemo->Destroy(codec);
653 
654     format = OH_AVFormat_Create();
655     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
656     result0 = aDecBufferDemo->SetCallback(codec);
657     channel = 2;  // 2 channel
658     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
659     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
660     result0 = aDecBufferDemo->Destroy(codec);
661 
662     delete aDecBufferDemo;
663 }
664 
665 /**
666  * @tc.number    : PARAM_CHECK_012
667  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB) param check
668  * @tc.desc      : param check test
669  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_012, TestSize.Level2)670 HWTEST_F(ParamCheckTest, PARAM_CHECK_012, TestSize.Level2)
671 {
672     OH_AVCodec *codec = nullptr;
673     OH_AVFormat *format = OH_AVFormat_Create();
674     int32_t channel = 1;
675     int32_t sampleRate = 8000;  // 8000hz
676     OH_AVErrCode result0;
677     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
678     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
679     result0 = aDecBufferDemo->SetCallback(codec);
680     sampleRate = 8000;  // 8000hz
681     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
682     ASSERT_EQ(result0, AV_ERR_OK);
683     result0 = aDecBufferDemo->Destroy(codec);
684 
685     format = OH_AVFormat_Create();
686     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
687     result0 = aDecBufferDemo->SetCallback(codec);
688     sampleRate = 7999;  // 7999hz
689     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
690     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
691     result0 = aDecBufferDemo->Destroy(codec);
692 
693     format = OH_AVFormat_Create();
694     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
695     result0 = aDecBufferDemo->SetCallback(codec);
696     sampleRate = 8001;  // 8001hz
697     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
698     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
699     result0 = aDecBufferDemo->Destroy(codec);
700 
701     delete aDecBufferDemo;
702 }
703 
704 /**
705  * @tc.number    : PARAM_CHECK_013
706  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB) param check
707  * @tc.desc      : param check test
708  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_013, TestSize.Level2)709 HWTEST_F(ParamCheckTest, PARAM_CHECK_013, TestSize.Level2)
710 {
711     OH_AVCodec *codec = nullptr;
712     OH_AVFormat *format = OH_AVFormat_Create();
713     int32_t channel = 1;
714     int32_t sampleRate = 16000;  // 16000hz
715     OH_AVErrCode result0;
716     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
717     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
718     result0 = aDecBufferDemo->SetCallback(codec);
719     channel = 1;
720     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
721     ASSERT_EQ(result0, AV_ERR_OK);
722     result0 = aDecBufferDemo->Destroy(codec);
723 
724     format = OH_AVFormat_Create();
725     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
726     result0 = aDecBufferDemo->SetCallback(codec);
727     channel = 0;
728     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
729     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
730     result0 = aDecBufferDemo->Destroy(codec);
731 
732     format = OH_AVFormat_Create();
733     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
734     result0 = aDecBufferDemo->SetCallback(codec);
735     channel = 2;  // 2 channel
736     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
737     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
738     result0 = aDecBufferDemo->Destroy(codec);
739 
740     delete aDecBufferDemo;
741 }
742 
743 /**
744  * @tc.number    : PARAM_CHECK_014
745  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB) param check
746  * @tc.desc      : param check test
747  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_014, TestSize.Level2)748 HWTEST_F(ParamCheckTest, PARAM_CHECK_014, TestSize.Level2)
749 {
750     OH_AVCodec *codec = nullptr;
751     OH_AVFormat *format = OH_AVFormat_Create();
752     int32_t channel = 1;
753     int32_t sampleRate = 16000;  // 16000hz
754     OH_AVErrCode result0;
755     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
756     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
757     result0 = aDecBufferDemo->SetCallback(codec);
758     sampleRate = 16000;  // 16000hz
759     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
760     ASSERT_EQ(result0, AV_ERR_OK);
761     result0 = aDecBufferDemo->Destroy(codec);
762 
763     format = OH_AVFormat_Create();
764     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
765     result0 = aDecBufferDemo->SetCallback(codec);
766     sampleRate = 15999;  // 15999hz
767     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
768     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
769     result0 = aDecBufferDemo->Destroy(codec);
770 
771     format = OH_AVFormat_Create();
772     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB);
773     result0 = aDecBufferDemo->SetCallback(codec);
774     sampleRate = 16001;  // 16001hz
775     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
776     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
777     result0 = aDecBufferDemo->Destroy(codec);
778 
779     delete aDecBufferDemo;
780 }
781 
782 /**
783  * @tc.number    : PARAM_CHECK_016
784  * @tc.name      : Configure - channel(OH_AVCODEC_MIMETYPE_AUDIO_G711MU) param check
785  * @tc.desc      : param check test
786  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_016, TestSize.Level2)787 HWTEST_F(ParamCheckTest, PARAM_CHECK_016, TestSize.Level2)
788 {
789     OH_AVCodec *codec = nullptr;
790     OH_AVFormat *format = OH_AVFormat_Create();
791     int32_t channel = 1;
792     int32_t sampleRate = 8000;  // 8000hz
793     OH_AVErrCode result0;
794     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
795     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
796     result0 = aDecBufferDemo->SetCallback(codec);
797     channel = 1;
798     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
799     ASSERT_EQ(result0, AV_ERR_OK);
800     result0 = aDecBufferDemo->Destroy(codec);
801 
802     format = OH_AVFormat_Create();
803     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
804     result0 = aDecBufferDemo->SetCallback(codec);
805     channel = 0;
806     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
807     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
808     result0 = aDecBufferDemo->Destroy(codec);
809 
810     format = OH_AVFormat_Create();
811     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
812     result0 = aDecBufferDemo->SetCallback(codec);
813     channel = 2;  // 2 channel
814     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
815     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
816     result0 = aDecBufferDemo->Destroy(codec);
817 
818     delete aDecBufferDemo;
819 }
820 
821 /**
822  * @tc.number    : PARAM_CHECK_017
823  * @tc.name      : Configure - sampleRate(OH_AVCODEC_MIMETYPE_AUDIO_G711MU) param check
824  * @tc.desc      : param check test
825  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_017, TestSize.Level2)826 HWTEST_F(ParamCheckTest, PARAM_CHECK_017, TestSize.Level2)
827 {
828     OH_AVCodec *codec = nullptr;
829     OH_AVFormat *format = OH_AVFormat_Create();
830     int32_t channel = 1;
831     int32_t sampleRate = 8000;  // 8000hz
832     OH_AVErrCode result0;
833     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
834     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
835     result0 = aDecBufferDemo->SetCallback(codec);
836     sampleRate = 8000;  // 8000hz
837     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
838     ASSERT_EQ(result0, AV_ERR_OK);
839     result0 = aDecBufferDemo->Destroy(codec);
840 
841     format = OH_AVFormat_Create();
842     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
843     result0 = aDecBufferDemo->SetCallback(codec);
844     sampleRate = 7999;  // 7999hz
845     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
846     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
847     result0 = aDecBufferDemo->Destroy(codec);
848 
849     format = OH_AVFormat_Create();
850     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
851     result0 = aDecBufferDemo->SetCallback(codec);
852     sampleRate = 8001;  // 8001hz
853     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
854     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
855     result0 = aDecBufferDemo->Destroy(codec);
856 
857     delete aDecBufferDemo;
858 }
859 
860 /**
861  * @tc.number    : PARAM_CHECK_021
862  * @tc.name      : FreeOutputData - index param check
863  * @tc.desc      : param check test
864  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_021, TestSize.Level2)865 HWTEST_F(ParamCheckTest, PARAM_CHECK_021, TestSize.Level2)
866 {
867     OH_AVCodec *codec = nullptr;
868     OH_AVFormat *format = OH_AVFormat_Create();
869     int32_t channel = 1;
870     int32_t sampleRate = 8000;  // 8000hz
871     uint32_t index;
872     OH_AVErrCode result0;
873     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
874     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
875     ASSERT_NE(codec, nullptr);
876     result0 = aDecBufferDemo->SetCallback(codec);
877     ASSERT_EQ(result0, AV_ERR_OK);
878     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
879     ASSERT_EQ(result0, AV_ERR_OK);
880     result0 = aDecBufferDemo->Start(codec);
881     ASSERT_EQ(result0, AV_ERR_OK);
882     index = aDecBufferDemo->GetInputIndex();
883     index = 8;
884     result0 = aDecBufferDemo->PushInputData(codec, index);
885     ASSERT_NE(result0, AV_ERR_OK);
886     index = aDecBufferDemo->GetOutputIndex();
887     index = -1;
888     result0 = aDecBufferDemo->FreeOutputData(codec, index);
889     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
890     result0 = aDecBufferDemo->Destroy(codec);
891 
892     delete aDecBufferDemo;
893 }
894 
895 /**
896  * @tc.number    : PARAM_CHECK_022
897  * @tc.name      : PushInputDataEOS - index param check
898  * @tc.desc      : param check test
899  */
HWTEST_F(ParamCheckTest, PARAM_CHECK_022, TestSize.Level2)900 HWTEST_F(ParamCheckTest, PARAM_CHECK_022, TestSize.Level2)
901 {
902     OH_AVCodec *codec = nullptr;
903     OH_AVFormat *format = OH_AVFormat_Create();
904     int32_t channel = 1;
905     int32_t sampleRate = 8000;  // 8000hz
906     uint32_t index;
907     OH_AVErrCode result0;
908     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
909     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
910     ASSERT_NE(codec, nullptr);
911     result0 = aDecBufferDemo->SetCallback(codec);
912     ASSERT_EQ(result0, AV_ERR_OK);
913     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
914     ASSERT_EQ(result0, AV_ERR_OK);
915     result0 = aDecBufferDemo->Start(codec);
916     ASSERT_EQ(result0, AV_ERR_OK);
917     index = aDecBufferDemo->GetInputIndex();
918     index = -1;
919     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
920     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
921     result0 = aDecBufferDemo->Destroy(codec);
922 
923     format = OH_AVFormat_Create();
924     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
925     ASSERT_NE(codec, nullptr);
926     result0 = aDecBufferDemo->SetCallback(codec);
927     ASSERT_EQ(result0, AV_ERR_OK);
928     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
929     ASSERT_EQ(result0, AV_ERR_OK);
930     result0 = aDecBufferDemo->Start(codec);
931     ASSERT_EQ(result0, AV_ERR_OK);
932     index = aDecBufferDemo->GetInputIndex();
933     index = 8;
934     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
935     ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
936     result0 = aDecBufferDemo->Destroy(codec);
937 
938     delete aDecBufferDemo;
939 }
940