1 /*
2  * Copyright (C) 2022 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 <string>
17 #include "gtest/gtest.h"
18 #include "AudioDecoderDemoCommon.h"
19 
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS;
23 using namespace OHOS::MediaAVCodec;
24 
25 namespace {
26 class NativeParamCheckTest : public testing::Test {
27 public:
28     static void SetUpTestCase();
29     static void TearDownTestCase();
30     void SetUp() override;
31     void TearDown() override;
32 };
33 
SetUpTestCase()34 void NativeParamCheckTest::SetUpTestCase() {}
TearDownTestCase()35 void NativeParamCheckTest::TearDownTestCase() {}
SetUp()36 void NativeParamCheckTest::SetUp() {}
TearDown()37 void NativeParamCheckTest::TearDown() {}
38 } // namespace
39 
40 /**
41  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_001
42  * @tc.name      : OH_AudioDecoder_CreateByMime - mime check
43  * @tc.desc      : param check test
44  */
45 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_001, TestSize.Level2)
46 {
47     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
48     OH_AVCodec *handle = decoderDemo->NativeCreateByMime("aaa");
49     ASSERT_EQ(nullptr, handle);
50 
51     handle = decoderDemo->NativeCreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
52     ASSERT_NE(nullptr, handle);
53 
54     decoderDemo->NativeDestroy(handle);
55     handle = nullptr;
56     handle = decoderDemo->NativeCreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
57     ASSERT_NE(nullptr, handle);
58     decoderDemo->NativeDestroy(handle);
59     delete decoderDemo;
60 }
61 
62 /**
63  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_002
64  * @tc.name      : OH_AudioDecoder_CreateByName - name check
65  * @tc.desc      : param check test
66  */
67 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_002, TestSize.Level2)
68 {
69     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
70     OH_AVCodec *handle = decoderDemo->NativeCreateByName("aaa");
71     ASSERT_EQ(nullptr, handle);
72 
73     handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
74     ASSERT_EQ(nullptr, handle);
75 
76     handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.AAC");
77     ASSERT_NE(nullptr, handle);
78 
79     decoderDemo->NativeDestroy(handle);
80     handle = nullptr;
81     handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
82     ASSERT_NE(nullptr, handle);
83 
84     decoderDemo->NativeDestroy(handle);
85     handle = nullptr;
86     handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Flac");
87     ASSERT_NE(nullptr, handle);
88 
89     decoderDemo->NativeDestroy(handle);
90     handle = nullptr;
91     handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Vorbis");
92     ASSERT_NE(nullptr, handle);
93 
94     decoderDemo->NativeDestroy(handle);
95     handle = nullptr;
96     handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Amrwb");
97     ASSERT_NE(nullptr, handle);
98 
99     decoderDemo->NativeDestroy(handle);
100     handle = nullptr;
101     handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Amrnb");
102     ASSERT_NE(nullptr, handle);
103 
104     decoderDemo->NativeDestroy(handle);
105     handle = nullptr;
106     handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.G711mu");
107     ASSERT_NE(nullptr, handle);
108 
109     decoderDemo->NativeDestroy(handle);
110     delete decoderDemo;
111 }
112 
113 /**
114  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_003
115  * @tc.name      : OH_AudioDecoder_Configure - format(MD_KEY_BITRATE) check
116  * @tc.desc      : param check test
117  */
118 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_003, TestSize.Level2)
119 {
120     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
121     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
122     ASSERT_NE(nullptr, handle);
123 
124     OH_AVFormat *format = OH_AVFormat_Create();
125     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
126     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
127     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
128 
129     OH_AVErrCode ret = decoderDemo->NativeConfigure(handle, format);
130     ASSERT_EQ(AV_ERR_OK, ret);
131 
132     decoderDemo->NativeReset(handle);
133     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, -1);
134     ret = decoderDemo->NativeConfigure(handle, format);
135     ASSERT_EQ(AV_ERR_OK, ret);
136 
137     decoderDemo->NativeReset(handle);
138     OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, 1);
139     ret = decoderDemo->NativeConfigure(handle, format);
140     ASSERT_EQ(AV_ERR_OK, ret);
141 
142     decoderDemo->NativeReset(handle);
143     OH_AVFormat_SetStringValue(format, OH_MD_KEY_BITRATE, "aaa");
144     ret = decoderDemo->NativeConfigure(handle, format);
145     ASSERT_EQ(AV_ERR_OK, ret);
146 
147     decoderDemo->NativeReset(handle);
148     OH_AVFormat_SetFloatValue(format, OH_MD_KEY_BITRATE, 0.1);
149     ret = decoderDemo->NativeConfigure(handle, format);
150     ASSERT_EQ(AV_ERR_OK, ret);
151 
152     decoderDemo->NativeReset(handle);
153     OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_BITRATE, 0.1);
154     ret = decoderDemo->NativeConfigure(handle, format);
155     ASSERT_EQ(AV_ERR_OK, ret);
156 
157     uint8_t a[100];
158     decoderDemo->NativeReset(handle);
159     OH_AVFormat_SetBuffer(format, OH_MD_KEY_BITRATE, a, 100);
160     ret = decoderDemo->NativeConfigure(handle, format);
161     ASSERT_EQ(AV_ERR_OK, ret);
162 
163     OH_AVFormat_Destroy(format);
164     decoderDemo->NativeDestroy(handle);
165     delete decoderDemo;
166 }
167 
168 /**
169  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_004
170  * @tc.name      : OH_AudioDecoder_Configure - format(OH_MD_KEY_AUD_CHANNEL_COUNT) check
171  * @tc.desc      : param check test
172  */
173 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_004, TestSize.Level2)
174 {
175     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
176     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
177     ASSERT_NE(nullptr, handle);
178 
179     OH_AVFormat *format = OH_AVFormat_Create();
180     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
181     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
182     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
183 
184     OH_AVErrCode ret = decoderDemo->NativeConfigure(handle, format);
185     ASSERT_EQ(AV_ERR_OK, ret);
186 
187     decoderDemo->NativeReset(handle);
188     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, -1);
189     ret = decoderDemo->NativeConfigure(handle, format);
190     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
191 
192     decoderDemo->NativeReset(handle);
193     OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, "aaa");
194     ret = decoderDemo->NativeConfigure(handle, format);
195     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
196 
197     decoderDemo->NativeReset(handle);
198     OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0);
199     ret = decoderDemo->NativeConfigure(handle, format);
200     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
201 
202     decoderDemo->NativeReset(handle);
203     OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
204     ret = decoderDemo->NativeConfigure(handle, format);
205     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
206 
207     decoderDemo->NativeReset(handle);
208     OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
209     ret = decoderDemo->NativeConfigure(handle, format);
210     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
211 
212     uint8_t a[100];
213     decoderDemo->NativeReset(handle);
214     OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_CHANNEL_COUNT, a, 100);
215     ret = decoderDemo->NativeConfigure(handle, format);
216     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
217 
218     OH_AVFormat_Destroy(format);
219     decoderDemo->NativeDestroy(handle);
220     delete decoderDemo;
221 }
222 
223 /**
224  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_005
225  * @tc.name      : OH_AudioDecoder_Configure - format(OH_MD_KEY_AUD_SAMPLE_RATE) check
226  * @tc.desc      : param check test
227  */
228 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_005, TestSize.Level2)
229 {
230     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
231     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
232     ASSERT_NE(nullptr, handle);
233 
234     OH_AVFormat *format = OH_AVFormat_Create();
235     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
236     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
237     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
238 
239     OH_AVErrCode ret = decoderDemo->NativeConfigure(handle, format);
240     ASSERT_EQ(AV_ERR_OK, ret);
241 
242     decoderDemo->NativeReset(handle);
243     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, -1);
244     ret = decoderDemo->NativeConfigure(handle, format);
245     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
246 
247     decoderDemo->NativeReset(handle);
248     OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, "aaa");
249     ret = decoderDemo->NativeConfigure(handle, format);
250     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
251 
252     decoderDemo->NativeReset(handle);
253     OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0);
254     ret = decoderDemo->NativeConfigure(handle, format);
255     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
256 
257     decoderDemo->NativeReset(handle);
258     OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
259     ret = decoderDemo->NativeConfigure(handle, format);
260     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
261 
262     decoderDemo->NativeReset(handle);
263     OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
264     ret = decoderDemo->NativeConfigure(handle, format);
265     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
266 
267     uint8_t a[100];
268     decoderDemo->NativeReset(handle);
269     OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_SAMPLE_RATE, a, 100);
270     ret = decoderDemo->NativeConfigure(handle, format);
271     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
272 
273     OH_AVFormat_Destroy(format);
274     decoderDemo->NativeDestroy(handle);
275     delete decoderDemo;
276 }
277 
278 /**
279  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_006
280  * @tc.name      : OH_AudioDecoder_SetParameter - format(MD_KEY_BITRATE) check
281  * @tc.desc      : param check test
282  */
283 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_006, TestSize.Level2)
284 {
285     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
286     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
287     ASSERT_NE(nullptr, handle);
288 
289     OH_AVFormat *format = OH_AVFormat_Create();
290     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
291     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
292     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
293 
294     OH_AVErrCode ret = decoderDemo->NativeConfigure(handle, format);
295     ASSERT_EQ(AV_ERR_OK, ret);
296 
297     ret = decoderDemo->NativePrepare(handle);
298     ASSERT_EQ(AV_ERR_OK, ret);
299     ret = decoderDemo->NativeStart(handle);
300     ASSERT_EQ(AV_ERR_OK, ret);
301 
302     ret = decoderDemo->NativeSetParameter(handle, format);
303     ASSERT_EQ(AV_ERR_OK, ret);
304 
305     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, -1);
306     ret = decoderDemo->NativeSetParameter(handle, format);
307     ASSERT_EQ(AV_ERR_OK, ret);
308 
309     OH_AVFormat_SetStringValue(format, OH_MD_KEY_BITRATE, "aaa");
310     ret = decoderDemo->NativeSetParameter(handle, format);
311     ASSERT_EQ(AV_ERR_OK, ret);
312 
313     OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, 0);
314     ret = decoderDemo->NativeSetParameter(handle, format);
315     ASSERT_EQ(AV_ERR_OK, ret);
316 
317     OH_AVFormat_SetFloatValue(format, OH_MD_KEY_BITRATE, 0.1);
318     ret = decoderDemo->NativeSetParameter(handle, format);
319     ASSERT_EQ(AV_ERR_OK, ret);
320 
321     OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_BITRATE, 0.1);
322     ret = decoderDemo->NativeSetParameter(handle, format);
323     ASSERT_EQ(AV_ERR_OK, ret);
324 
325     uint8_t a[100];
326     OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_SAMPLE_RATE, a, 100);
327     ret = decoderDemo->NativeSetParameter(handle, format);
328     ASSERT_EQ(AV_ERR_OK, ret);
329 
330     OH_AVFormat_Destroy(format);
331     decoderDemo->NativeDestroy(handle);
332     delete decoderDemo;
333 }
334 
335 /**
336  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_007
337  * @tc.name      : OH_AudioDecoder_SetParameter - format(OH_MD_KEY_AUD_CHANNEL_COUNT) check
338  * @tc.desc      : param check test
339  */
340 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_007, TestSize.Level2)
341 {
342     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
343     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
344     ASSERT_NE(nullptr, handle);
345 
346     OH_AVFormat *format = OH_AVFormat_Create();
347     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
348     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
349     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
350 
351     OH_AVErrCode ret = decoderDemo->NativeConfigure(handle, format);
352     ASSERT_EQ(AV_ERR_OK, ret);
353 
354     ret = decoderDemo->NativePrepare(handle);
355     ASSERT_EQ(AV_ERR_OK, ret);
356     ret = decoderDemo->NativeStart(handle);
357     ASSERT_EQ(AV_ERR_OK, ret);
358 
359     ret = decoderDemo->NativeSetParameter(handle, format);
360     ASSERT_EQ(AV_ERR_OK, ret);
361 
362     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, -1);
363     ret = decoderDemo->NativeSetParameter(handle, format);
364     ASSERT_EQ(AV_ERR_OK, ret);
365 
366     OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, "aaa");
367     ret = decoderDemo->NativeSetParameter(handle, format);
368     ASSERT_EQ(AV_ERR_OK, ret);
369 
370     OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0);
371     ret = decoderDemo->NativeSetParameter(handle, format);
372     ASSERT_EQ(AV_ERR_OK, ret);
373 
374     OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
375     ret = decoderDemo->NativeSetParameter(handle, format);
376     ASSERT_EQ(AV_ERR_OK, ret);
377 
378     OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
379     ret = decoderDemo->NativeSetParameter(handle, format);
380     ASSERT_EQ(AV_ERR_OK, ret);
381 
382     uint8_t a[100];
383     OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_CHANNEL_COUNT, a, 100);
384     ret = decoderDemo->NativeSetParameter(handle, format);
385     ASSERT_EQ(AV_ERR_OK, ret);
386 
387     OH_AVFormat_Destroy(format);
388     decoderDemo->NativeDestroy(handle);
389     delete decoderDemo;
390 }
391 
392 /**
393  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_008
394  * @tc.name      : OH_AudioDecoder_SetParameter - format(OH_MD_KEY_AUD_SAMPLE_RATE) check
395  * @tc.desc      : param check test
396  */
397 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_008, TestSize.Level2)
398 {
399     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
400     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
401     ASSERT_NE(nullptr, handle);
402 
403     OH_AVFormat *format = OH_AVFormat_Create();
404     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
405     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
406     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
407 
408     OH_AVErrCode ret = decoderDemo->NativeConfigure(handle, format);
409     ASSERT_EQ(AV_ERR_OK, ret);
410 
411     ret = decoderDemo->NativePrepare(handle);
412     ASSERT_EQ(AV_ERR_OK, ret);
413     ret = decoderDemo->NativeStart(handle);
414     ASSERT_EQ(AV_ERR_OK, ret);
415 
416     ret = decoderDemo->NativeSetParameter(handle, format);
417     ASSERT_EQ(AV_ERR_OK, ret);
418 
419     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, -1);
420     ret = decoderDemo->NativeSetParameter(handle, format);
421     ASSERT_EQ(AV_ERR_OK, ret);
422 
423     OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, "aaa");
424     ret = decoderDemo->NativeSetParameter(handle, format);
425     ASSERT_EQ(AV_ERR_OK, ret);
426 
427     OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0);
428     ret = decoderDemo->NativeSetParameter(handle, format);
429     ASSERT_EQ(AV_ERR_OK, ret);
430 
431     OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
432     ret = decoderDemo->NativeSetParameter(handle, format);
433     ASSERT_EQ(AV_ERR_OK, ret);
434 
435     OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
436     ret = decoderDemo->NativeSetParameter(handle, format);
437     ASSERT_EQ(AV_ERR_OK, ret);
438 
439     uint8_t a[100];
440     OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_SAMPLE_RATE, a, 100);
441     ret = decoderDemo->NativeSetParameter(handle, format);
442     ASSERT_EQ(AV_ERR_OK, ret);
443 
444     OH_AVFormat_Destroy(format);
445     decoderDemo->NativeDestroy(handle);
446     delete decoderDemo;
447 }
448 
449 /**
450  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_009
451  * @tc.name      : OH_AudioDecoder_PushInputData - index check
452  * @tc.desc      : param check test
453  */
454 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_009, TestSize.Level2)
455 {
456     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
457     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
458     ASSERT_NE(nullptr, handle);
459 
460     OH_AVFormat *format = OH_AVFormat_Create();
461     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
462     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
463     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
464 
465     struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
466                                          &OnOutputBufferAvailable};
467     OH_AVErrCode ret = decoderDemo->NativeSetCallback(handle, cb);
468     ASSERT_EQ(AV_ERR_OK, ret);
469 
470     ret = decoderDemo->NativeConfigure(handle, format);
471     ASSERT_EQ(AV_ERR_OK, ret);
472 
473     ret = decoderDemo->NativePrepare(handle);
474     ASSERT_EQ(AV_ERR_OK, ret);
475     ret = decoderDemo->NativeStart(handle);
476     ASSERT_EQ(AV_ERR_OK, ret);
477 
478     OH_AVCodecBufferAttr info;
479     info.size = 100;
480     info.offset = 0;
481     info.pts = 0;
482     info.flags = AVCODEC_BUFFER_FLAGS_NONE;
483 
484     uint32_t index = decoderDemo->NativeGetInputIndex();
485     ret = decoderDemo->NativePushInputData(handle, index, info);
486     ASSERT_EQ(AV_ERR_OK, ret);
487 
488     ret = decoderDemo->NativePushInputData(handle, -1, info);
489     ASSERT_EQ(AV_ERR_NO_MEMORY, ret);
490 
491     OH_AVFormat_Destroy(format);
492     decoderDemo->NativeDestroy(handle);
493     delete decoderDemo;
494 }
495 
496 /**
497  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_010
498  * @tc.name      : OH_AudioDecoder_PushInputData - info.size check
499  * @tc.desc      : param check test
500  */
501 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_010, TestSize.Level2)
502 {
503     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
504     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
505     ASSERT_NE(nullptr, handle);
506 
507     OH_AVFormat *format = OH_AVFormat_Create();
508     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
509     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
510     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
511 
512     struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
513                                          &OnOutputBufferAvailable};
514     OH_AVErrCode ret = decoderDemo->NativeSetCallback(handle, cb);
515     ASSERT_EQ(AV_ERR_OK, ret);
516 
517     ret = decoderDemo->NativeConfigure(handle, format);
518     ASSERT_EQ(AV_ERR_OK, ret);
519 
520     ret = decoderDemo->NativePrepare(handle);
521     ASSERT_EQ(AV_ERR_OK, ret);
522     ret = decoderDemo->NativeStart(handle);
523     ASSERT_EQ(AV_ERR_OK, ret);
524 
525     OH_AVCodecBufferAttr info;
526     info.size = 100;
527     info.offset = 0;
528     info.pts = 0;
529     info.flags = AVCODEC_BUFFER_FLAGS_NONE;
530 
531     uint32_t index = decoderDemo->NativeGetInputIndex();
532     ret = decoderDemo->NativePushInputData(handle, index, info);
533     ASSERT_EQ(AV_ERR_OK, ret);
534 
535     index = decoderDemo->NativeGetInputIndex();
536     info.size = -1;
537     ret = decoderDemo->NativePushInputData(handle, index, info);
538     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
539 
540     OH_AVFormat_Destroy(format);
541     decoderDemo->NativeDestroy(handle);
542     delete decoderDemo;
543 }
544 
545 /**
546  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_011
547  * @tc.name      : OH_AudioDecoder_PushInputData - info.offset check
548  * @tc.desc      : param check test
549  */
550 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_011, TestSize.Level2)
551 {
552     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
553     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
554     ASSERT_NE(nullptr, handle);
555 
556     OH_AVFormat *format = OH_AVFormat_Create();
557     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
558     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
559     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
560 
561     struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
562                                          &OnOutputBufferAvailable};
563     OH_AVErrCode ret = decoderDemo->NativeSetCallback(handle, cb);
564     ASSERT_EQ(AV_ERR_OK, ret);
565 
566     ret = decoderDemo->NativeConfigure(handle, format);
567     ASSERT_EQ(AV_ERR_OK, ret);
568 
569     ret = decoderDemo->NativePrepare(handle);
570     ASSERT_EQ(AV_ERR_OK, ret);
571     ret = decoderDemo->NativeStart(handle);
572     ASSERT_EQ(AV_ERR_OK, ret);
573 
574     OH_AVCodecBufferAttr info;
575     info.size = 100;
576     info.offset = 0;
577     info.pts = 0;
578     info.flags = AVCODEC_BUFFER_FLAGS_NONE;
579 
580     uint32_t index = decoderDemo->NativeGetInputIndex();
581     ret = decoderDemo->NativePushInputData(handle, index, info);
582     ASSERT_EQ(AV_ERR_OK, ret);
583 
584     index = decoderDemo->NativeGetInputIndex();
585     info.offset = -1;
586     ret = decoderDemo->NativePushInputData(handle, index, info);
587     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
588 
589     OH_AVFormat_Destroy(format);
590     decoderDemo->NativeDestroy(handle);
591     delete decoderDemo;
592 }
593 
594 /**
595  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_012
596  * @tc.name      : OH_AudioDecoder_PushInputData - info.pts check
597  * @tc.desc      : param check test
598  */
599 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_012, TestSize.Level2)
600 {
601     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
602     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
603     ASSERT_NE(nullptr, handle);
604 
605     OH_AVFormat *format = OH_AVFormat_Create();
606     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
607     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
608     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
609 
610     struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
611                                          &OnOutputBufferAvailable};
612     OH_AVErrCode ret = decoderDemo->NativeSetCallback(handle, cb);
613     ASSERT_EQ(AV_ERR_OK, ret);
614 
615     ret = decoderDemo->NativeConfigure(handle, format);
616     ASSERT_EQ(AV_ERR_OK, ret);
617 
618     ret = decoderDemo->NativePrepare(handle);
619     ASSERT_EQ(AV_ERR_OK, ret);
620     ret = decoderDemo->NativeStart(handle);
621     ASSERT_EQ(AV_ERR_OK, ret);
622 
623     OH_AVCodecBufferAttr info;
624     info.size = 100;
625     info.offset = 0;
626     info.pts = 0;
627     info.flags = AVCODEC_BUFFER_FLAGS_NONE;
628 
629     uint32_t index = decoderDemo->NativeGetInputIndex();
630     ret = decoderDemo->NativePushInputData(handle, index, info);
631     ASSERT_EQ(AV_ERR_OK, ret);
632 
633     index = decoderDemo->NativeGetInputIndex();
634     info.pts = -1;
635     ret = decoderDemo->NativePushInputData(handle, index, info);
636     ASSERT_EQ(AV_ERR_OK, ret);
637 
638     OH_AVFormat_Destroy(format);
639     decoderDemo->NativeDestroy(handle);
640     delete decoderDemo;
641 }
642 
643 /**
644  * @tc.number    : SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_013
645  * @tc.name      : OH_AudioDecoder_FreeOutputData - index check
646  * @tc.desc      : param check test
647  */
648 HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_DECODER_PARAM_CHECK_013, TestSize.Level2)
649 {
650     AudioDecoderDemo *decoderDemo = new AudioDecoderDemo();
651     OH_AVCodec *handle = decoderDemo->NativeCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
652     ASSERT_NE(nullptr, handle);
653 
654     OH_AVFormat *format = OH_AVFormat_Create();
655     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
656     OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
657     OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
658 
659     struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
660                                          &OnOutputBufferAvailable};
661     OH_AVErrCode ret = decoderDemo->NativeSetCallback(handle, cb);
662     ASSERT_EQ(AV_ERR_OK, ret);
663 
664     ret = decoderDemo->NativeConfigure(handle, format);
665     ASSERT_EQ(AV_ERR_OK, ret);
666 
667     ret = decoderDemo->NativePrepare(handle);
668     ASSERT_EQ(AV_ERR_OK, ret);
669     ret = decoderDemo->NativeStart(handle);
670     ASSERT_EQ(AV_ERR_OK, ret);
671 
672     ret = decoderDemo->NativeFreeOutputData(handle, -1);
673     ASSERT_EQ(AV_ERR_NO_MEMORY, ret);
674 
675     OH_AVFormat_Destroy(format);
676     decoderDemo->NativeDestroy(handle);
677     delete decoderDemo;
678 }