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 "AudioEncoderDemoCommon.h"
19
20using namespace std;
21using namespace testing::ext;
22using namespace OHOS;
23using namespace OHOS::MediaAVCodec;
24
25namespace {
26class NativeParamCheckTest : public testing::Test {
27public:
28    static void SetUpTestCase();
29    static void TearDownTestCase();
30    void SetUp() override;
31    void TearDown() override;
32};
33
34void NativeParamCheckTest::SetUpTestCase() {}
35void NativeParamCheckTest::TearDownTestCase() {}
36void NativeParamCheckTest::SetUp() {}
37void NativeParamCheckTest::TearDown() {}
38
39constexpr int32_t CHANNEL_COUNT_FLAC = 2;
40constexpr int32_t SAMPLE_RATE_FLAC = 48000;
41constexpr int64_t BITS_RATE_FLAC = 128000;
42} // namespace
43
44/**
45 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_001
46 * @tc.name      : OH_AudioEncoder_CreateByMime - mime check
47 * @tc.desc      : param check test
48 */
49HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_001, TestSize.Level2)
50{
51    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
52    OH_AVCodec *handle = encoderDemo->NativeCreateByMime("aaa");
53    ASSERT_EQ(nullptr, handle);
54
55    handle = encoderDemo->NativeCreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
56    ASSERT_NE(nullptr, handle);
57
58    encoderDemo->NativeDestroy(handle);
59    handle = nullptr;
60    handle = encoderDemo->NativeCreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC);
61    ASSERT_NE(nullptr, handle);
62    encoderDemo->NativeDestroy(handle);
63    delete encoderDemo;
64}
65
66/**
67 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_002
68 * @tc.name      : OH_AudioEncoder_CreateByName - name check
69 * @tc.desc      : param check test
70 */
71HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_002, TestSize.Level2)
72{
73    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
74    OH_AVCodec *handle = encoderDemo->NativeCreateByName("aaa");
75    ASSERT_EQ(nullptr, handle);
76
77    handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
78    ASSERT_NE(nullptr, handle);
79    encoderDemo->NativeDestroy(handle);
80    handle = nullptr;
81
82    handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.Flac");
83    ASSERT_NE(nullptr, handle);
84    encoderDemo->NativeDestroy(handle);
85    handle = nullptr;
86    delete encoderDemo;
87}
88
89/**
90 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_003
91 * @tc.name      : OH_AudioEncoder_Configure - format(MD_KEY_BITRATE) check
92 * @tc.desc      : param check test
93 */
94HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_003, TestSize.Level2)
95{
96    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
97    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
98    ASSERT_NE(nullptr, handle);
99
100    OH_AVFormat *format = OH_AVFormat_Create();
101    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
102    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
103    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
104    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
105    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
106    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
107    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
108
109    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
110    ASSERT_EQ(AV_ERR_OK, ret);
111
112    encoderDemo->NativeReset(handle);
113    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, -1);
114    ret = encoderDemo->NativeConfigure(handle, format);
115    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
116
117    encoderDemo->NativeReset(handle);
118    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, 1);
119    ret = encoderDemo->NativeConfigure(handle, format);
120    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
121
122    encoderDemo->NativeReset(handle);
123    OH_AVFormat_SetStringValue(format, OH_MD_KEY_BITRATE, "aaa");
124    ret = encoderDemo->NativeConfigure(handle, format);
125    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
126
127    encoderDemo->NativeReset(handle);
128    OH_AVFormat_SetFloatValue(format, OH_MD_KEY_BITRATE, 0.1);
129    ret = encoderDemo->NativeConfigure(handle, format);
130    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
131
132    encoderDemo->NativeReset(handle);
133    OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_BITRATE, 0.1);
134    ret = encoderDemo->NativeConfigure(handle, format);
135    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
136
137    uint8_t a[100];
138    encoderDemo->NativeReset(handle);
139    OH_AVFormat_SetBuffer(format, OH_MD_KEY_BITRATE, a, 100);
140    ret = encoderDemo->NativeConfigure(handle, format);
141    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
142
143    OH_AVFormat_Destroy(format);
144    encoderDemo->NativeDestroy(handle);
145    delete encoderDemo;
146}
147
148/**
149 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_004
150 * @tc.name      : OH_AudioEncoder_Configure - format(OH_MD_KEY_AUD_CHANNEL_COUNT) check
151 * @tc.desc      : param check test
152 */
153HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_004, TestSize.Level2)
154{
155    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
156    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
157    ASSERT_NE(nullptr, handle);
158
159    OH_AVFormat *format = OH_AVFormat_Create();
160    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
161    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
162    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
163    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
164    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
165    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
166    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
167
168    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
169    ASSERT_EQ(AV_ERR_OK, ret);
170
171    encoderDemo->NativeReset(handle);
172    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, -1);
173    ret = encoderDemo->NativeConfigure(handle, format);
174    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
175
176    encoderDemo->NativeReset(handle);
177    OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, "aaa");
178    ret = encoderDemo->NativeConfigure(handle, format);
179    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
180
181    encoderDemo->NativeReset(handle);
182    OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0);
183    ret = encoderDemo->NativeConfigure(handle, format);
184    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
185
186    encoderDemo->NativeReset(handle);
187    OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
188    ret = encoderDemo->NativeConfigure(handle, format);
189    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
190
191    encoderDemo->NativeReset(handle);
192    OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
193    ret = encoderDemo->NativeConfigure(handle, format);
194    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
195
196    uint8_t a[100];
197    encoderDemo->NativeReset(handle);
198    OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_CHANNEL_COUNT, a, 100);
199    ret = encoderDemo->NativeConfigure(handle, format);
200    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
201
202    OH_AVFormat_Destroy(format);
203    encoderDemo->NativeDestroy(handle);
204    delete encoderDemo;
205}
206
207/**
208 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_005
209 * @tc.name      : OH_AudioEncoder_Configure - format(OH_MD_KEY_AUD_SAMPLE_RATE) check
210 * @tc.desc      : param check test
211 */
212HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_005, TestSize.Level2)
213{
214    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
215    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
216    ASSERT_NE(nullptr, handle);
217
218    OH_AVFormat *format = OH_AVFormat_Create();
219    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
220    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
221    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
222    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
223    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
224    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
225    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
226
227    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
228    ASSERT_EQ(AV_ERR_OK, ret);
229
230    encoderDemo->NativeReset(handle);
231    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, -1);
232    ret = encoderDemo->NativeConfigure(handle, format);
233    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
234
235    encoderDemo->NativeReset(handle);
236    OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, "aaa");
237    ret = encoderDemo->NativeConfigure(handle, format);
238    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
239
240    encoderDemo->NativeReset(handle);
241    OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0);
242    ret = encoderDemo->NativeConfigure(handle, format);
243    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
244
245    encoderDemo->NativeReset(handle);
246    OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
247    ret = encoderDemo->NativeConfigure(handle, format);
248    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
249
250    encoderDemo->NativeReset(handle);
251    OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
252    ret = encoderDemo->NativeConfigure(handle, format);
253    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
254
255    uint8_t a[100];
256    encoderDemo->NativeReset(handle);
257    OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_SAMPLE_RATE, a, 100);
258    ret = encoderDemo->NativeConfigure(handle, format);
259    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
260
261    OH_AVFormat_Destroy(format);
262    encoderDemo->NativeDestroy(handle);
263    delete encoderDemo;
264}
265
266/**
267 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_006
268 * @tc.name      : OH_AudioEncoder_SetParameter - format(MD_KEY_BITRATE) check
269 * @tc.desc      : param check test
270 */
271HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_006, TestSize.Level2)
272{
273    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
274    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
275    ASSERT_NE(nullptr, handle);
276
277    OH_AVFormat *format = OH_AVFormat_Create();
278    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
279    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
280    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
281    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
282    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
283    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
284    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
285
286    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
287    ASSERT_EQ(AV_ERR_OK, ret);
288
289    ret = encoderDemo->NativePrepare(handle);
290    ASSERT_EQ(AV_ERR_OK, ret);
291    ret = encoderDemo->NativeStart(handle);
292    ASSERT_EQ(AV_ERR_OK, ret);
293
294    ret = encoderDemo->NativeSetParameter(handle, format);
295    ASSERT_EQ(AV_ERR_OK, ret);
296
297    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, -1);
298    ret = encoderDemo->NativeSetParameter(handle, format);
299    ASSERT_EQ(AV_ERR_OK, ret);
300
301    OH_AVFormat_SetStringValue(format, OH_MD_KEY_BITRATE, "aaa");
302    ret = encoderDemo->NativeSetParameter(handle, format);
303    ASSERT_EQ(AV_ERR_OK, ret);
304
305    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, 0);
306    ret = encoderDemo->NativeSetParameter(handle, format);
307    ASSERT_EQ(AV_ERR_OK, ret);
308
309    OH_AVFormat_SetFloatValue(format, OH_MD_KEY_BITRATE, 0.1);
310    ret = encoderDemo->NativeSetParameter(handle, format);
311    ASSERT_EQ(AV_ERR_OK, ret);
312
313    OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_BITRATE, 0.1);
314    ret = encoderDemo->NativeSetParameter(handle, format);
315    ASSERT_EQ(AV_ERR_OK, ret);
316
317    uint8_t a[100];
318    OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_SAMPLE_RATE, a, 100);
319    ret = encoderDemo->NativeSetParameter(handle, format);
320    ASSERT_EQ(AV_ERR_OK, ret);
321
322    OH_AVFormat_Destroy(format);
323    encoderDemo->NativeDestroy(handle);
324    delete encoderDemo;
325}
326
327/**
328 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_007
329 * @tc.name      : OH_AudioEncoder_SetParameter - format(OH_MD_KEY_AUD_CHANNEL_COUNT) check
330 * @tc.desc      : param check test
331 */
332HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_007, TestSize.Level2)
333{
334    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
335    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
336    ASSERT_NE(nullptr, handle);
337
338    OH_AVFormat *format = OH_AVFormat_Create();
339    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
340    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
341    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
342    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
343    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
344    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
345    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
346
347    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
348    ASSERT_EQ(AV_ERR_OK, ret);
349
350    ret = encoderDemo->NativePrepare(handle);
351    ASSERT_EQ(AV_ERR_OK, ret);
352    ret = encoderDemo->NativeStart(handle);
353    ASSERT_EQ(AV_ERR_OK, ret);
354
355    ret = encoderDemo->NativeSetParameter(handle, format);
356    ASSERT_EQ(AV_ERR_OK, ret);
357
358    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, -1);
359    ret = encoderDemo->NativeSetParameter(handle, format);
360    ASSERT_EQ(AV_ERR_OK, ret);
361
362    OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, "aaa");
363    ret = encoderDemo->NativeSetParameter(handle, format);
364    ASSERT_EQ(AV_ERR_OK, ret);
365
366    OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0);
367    ret = encoderDemo->NativeSetParameter(handle, format);
368    ASSERT_EQ(AV_ERR_OK, ret);
369
370    OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
371    ret = encoderDemo->NativeSetParameter(handle, format);
372    ASSERT_EQ(AV_ERR_OK, ret);
373
374    OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
375    ret = encoderDemo->NativeSetParameter(handle, format);
376    ASSERT_EQ(AV_ERR_OK, ret);
377
378    uint8_t a[100];
379    OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_CHANNEL_COUNT, a, 100);
380    ret = encoderDemo->NativeSetParameter(handle, format);
381    ASSERT_EQ(AV_ERR_OK, ret);
382
383    OH_AVFormat_Destroy(format);
384    encoderDemo->NativeDestroy(handle);
385    delete encoderDemo;
386}
387
388/**
389 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_008
390 * @tc.name      : OH_AudioEncoder_SetParameter - format(OH_MD_KEY_AUD_SAMPLE_RATE) check
391 * @tc.desc      : param check test
392 */
393HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_008, TestSize.Level2)
394{
395    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
396    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
397    ASSERT_NE(nullptr, handle);
398
399    OH_AVFormat *format = OH_AVFormat_Create();
400    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
401    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
402    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
403    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
404    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
405    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
406    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
407
408    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
409    ASSERT_EQ(AV_ERR_OK, ret);
410
411    ret = encoderDemo->NativePrepare(handle);
412    ASSERT_EQ(AV_ERR_OK, ret);
413    ret = encoderDemo->NativeStart(handle);
414    ASSERT_EQ(AV_ERR_OK, ret);
415
416    ret = encoderDemo->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 = encoderDemo->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 = encoderDemo->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 = encoderDemo->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 = encoderDemo->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 = encoderDemo->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 = encoderDemo->NativeSetParameter(handle, format);
442    ASSERT_EQ(AV_ERR_OK, ret);
443
444    OH_AVFormat_Destroy(format);
445    encoderDemo->NativeDestroy(handle);
446    delete encoderDemo;
447}
448
449/**
450 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_009
451 * @tc.name      : OH_AudioEncoder_PushInputData - index check
452 * @tc.desc      : param check test
453 */
454HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_009, TestSize.Level2)
455{
456    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
457    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
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_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
464    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
465    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
466    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
467    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
468
469    struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
470                                         &OnOutputBufferAvailable};
471    OH_AVErrCode ret = encoderDemo->NativeSetCallback(handle, cb);
472    ASSERT_EQ(AV_ERR_OK, ret);
473
474    ret = encoderDemo->NativeConfigure(handle, format);
475    ASSERT_EQ(AV_ERR_OK, ret);
476
477    ret = encoderDemo->NativePrepare(handle);
478    ASSERT_EQ(AV_ERR_OK, ret);
479    ret = encoderDemo->NativeStart(handle);
480    ASSERT_EQ(AV_ERR_OK, ret);
481
482    OH_AVCodecBufferAttr info;
483    info.size = 100;
484    info.offset = 0;
485    info.pts = 0;
486    info.flags = AVCODEC_BUFFER_FLAGS_NONE;
487
488    uint32_t index = encoderDemo->NativeGetInputIndex();
489    ret = encoderDemo->NativePushInputData(handle, index, info);
490    ASSERT_EQ(AV_ERR_OK, ret);
491
492    ret = encoderDemo->NativePushInputData(handle, -1, info);
493    ASSERT_EQ(AV_ERR_NO_MEMORY, ret);
494
495    OH_AVFormat_Destroy(format);
496    encoderDemo->NativeDestroy(handle);
497    delete encoderDemo;
498}
499
500/**
501 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_010
502 * @tc.name      : OH_AudioEncoder_PushInputData - info.size check
503 * @tc.desc      : param check test
504 */
505HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_010, TestSize.Level2)
506{
507    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
508    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
509    ASSERT_NE(nullptr, handle);
510
511    OH_AVFormat *format = OH_AVFormat_Create();
512    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
513    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
514    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
515    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
516    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
517    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
518    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
519
520    struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
521                                         &OnOutputBufferAvailable};
522    OH_AVErrCode ret = encoderDemo->NativeSetCallback(handle, cb);
523    ASSERT_EQ(AV_ERR_OK, ret);
524
525    ret = encoderDemo->NativeConfigure(handle, format);
526    ASSERT_EQ(AV_ERR_OK, ret);
527
528    ret = encoderDemo->NativePrepare(handle);
529    ASSERT_EQ(AV_ERR_OK, ret);
530    ret = encoderDemo->NativeStart(handle);
531    ASSERT_EQ(AV_ERR_OK, ret);
532
533    OH_AVCodecBufferAttr info;
534    info.size = 100;
535    info.offset = 0;
536    info.pts = 0;
537    info.flags = AVCODEC_BUFFER_FLAGS_NONE;
538
539    uint32_t index = encoderDemo->NativeGetInputIndex();
540    ret = encoderDemo->NativePushInputData(handle, index, info);
541    ASSERT_EQ(AV_ERR_OK, ret);
542
543    index = encoderDemo->NativeGetInputIndex();
544    info.size = -1;
545    ret = encoderDemo->NativePushInputData(handle, index, info);
546    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
547
548    OH_AVFormat_Destroy(format);
549    encoderDemo->NativeDestroy(handle);
550    delete encoderDemo;
551}
552
553/**
554 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_011
555 * @tc.name      : OH_AudioEncoder_PushInputData - info.offset check
556 * @tc.desc      : param check test
557 */
558HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_011, TestSize.Level2)
559{
560    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
561    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
562    ASSERT_NE(nullptr, handle);
563
564    OH_AVFormat *format = OH_AVFormat_Create();
565    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
566    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
567    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
568    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
569    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
570    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
571    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
572
573    struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
574                                         &OnOutputBufferAvailable};
575    OH_AVErrCode ret = encoderDemo->NativeSetCallback(handle, cb);
576    ASSERT_EQ(AV_ERR_OK, ret);
577
578    ret = encoderDemo->NativeConfigure(handle, format);
579    ASSERT_EQ(AV_ERR_OK, ret);
580
581    ret = encoderDemo->NativePrepare(handle);
582    ASSERT_EQ(AV_ERR_OK, ret);
583    ret = encoderDemo->NativeStart(handle);
584    ASSERT_EQ(AV_ERR_OK, ret);
585
586    OH_AVCodecBufferAttr info;
587    info.size = 100;
588    info.offset = 0;
589    info.pts = 0;
590    info.flags = AVCODEC_BUFFER_FLAGS_NONE;
591
592    uint32_t index = encoderDemo->NativeGetInputIndex();
593    ret = encoderDemo->NativePushInputData(handle, index, info);
594    ASSERT_EQ(AV_ERR_OK, ret);
595
596    index = encoderDemo->NativeGetInputIndex();
597    info.offset = -1;
598    ret = encoderDemo->NativePushInputData(handle, index, info);
599    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
600
601    OH_AVFormat_Destroy(format);
602    encoderDemo->NativeDestroy(handle);
603    delete encoderDemo;
604}
605
606/**
607 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_012
608 * @tc.name      : OH_AudioEncoder_PushInputData - info.pts check
609 * @tc.desc      : param check test
610 */
611HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_012, TestSize.Level2)
612{
613    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
614    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
615    ASSERT_NE(nullptr, handle);
616
617    OH_AVFormat *format = OH_AVFormat_Create();
618    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
619    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
620    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
621    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
622    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
623    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
624    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
625
626    struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
627                                         &OnOutputBufferAvailable};
628    OH_AVErrCode ret = encoderDemo->NativeSetCallback(handle, cb);
629    ASSERT_EQ(AV_ERR_OK, ret);
630
631    ret = encoderDemo->NativeConfigure(handle, format);
632    ASSERT_EQ(AV_ERR_OK, ret);
633
634    ret = encoderDemo->NativePrepare(handle);
635    ASSERT_EQ(AV_ERR_OK, ret);
636    ret = encoderDemo->NativeStart(handle);
637    ASSERT_EQ(AV_ERR_OK, ret);
638
639    OH_AVCodecBufferAttr info;
640    info.size = 100;
641    info.offset = 0;
642    info.pts = 0;
643    info.flags = AVCODEC_BUFFER_FLAGS_NONE;
644
645    uint32_t index = encoderDemo->NativeGetInputIndex();
646    ret = encoderDemo->NativePushInputData(handle, index, info);
647    ASSERT_EQ(AV_ERR_OK, ret);
648
649    index = encoderDemo->NativeGetInputIndex();
650    info.pts = -1;
651    ret = encoderDemo->NativePushInputData(handle, index, info);
652    ASSERT_EQ(AV_ERR_OK, ret);
653
654    OH_AVFormat_Destroy(format);
655    encoderDemo->NativeDestroy(handle);
656    delete encoderDemo;
657}
658
659/**
660 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_013
661 * @tc.name      : OH_AudioEncoder_FreeOutputData - index check
662 * @tc.desc      : param check test
663 */
664HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_013, TestSize.Level2)
665{
666    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
667    OH_AVCodec *handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
668    ASSERT_NE(nullptr, handle);
669
670    OH_AVFormat *format = OH_AVFormat_Create();
671    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
672    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 44100);
673    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
674    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
675    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
676    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
677    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 169000);
678
679    struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
680                                         &OnOutputBufferAvailable};
681    OH_AVErrCode ret = encoderDemo->NativeSetCallback(handle, cb);
682    ASSERT_EQ(AV_ERR_OK, ret);
683
684    ret = encoderDemo->NativeConfigure(handle, format);
685    ASSERT_EQ(AV_ERR_OK, ret);
686
687    ret = encoderDemo->NativePrepare(handle);
688    ASSERT_EQ(AV_ERR_OK, ret);
689    ret = encoderDemo->NativeStart(handle);
690    ASSERT_EQ(AV_ERR_OK, ret);
691
692    ret = encoderDemo->NativeFreeOutputData(handle, -1);
693    ASSERT_EQ(AV_ERR_NO_MEMORY, ret);
694
695    OH_AVFormat_Destroy(format);
696    encoderDemo->NativeDestroy(handle);
697    delete encoderDemo;
698}
699
700
701/**
702 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_014
703 * @tc.name      : OH_AudioEncoder_Configure - format(FLAC MD_KEY_BITRATE) check
704 * @tc.desc      : param check test
705 */
706HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_014, TestSize.Level2)
707{
708    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
709    OH_AVCodec* handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.Flac");
710    ASSERT_NE(nullptr, handle);
711
712    OH_AVFormat* format = OH_AVFormat_Create();
713    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT_FLAC);
714    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE_FLAC);
715    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
716    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
717    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
718    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, BITS_RATE_FLAC);
719
720    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
721    ASSERT_EQ(AV_ERR_OK, ret);
722
723    encoderDemo->NativeReset(handle);
724    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, -1);
725    ret = encoderDemo->NativeConfigure(handle, format);
726    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
727
728    encoderDemo->NativeReset(handle);
729    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, 1);
730    ret = encoderDemo->NativeConfigure(handle, format);
731    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
732
733    encoderDemo->NativeReset(handle);
734    OH_AVFormat_SetStringValue(format, OH_MD_KEY_BITRATE, "aaa");
735    ret = encoderDemo->NativeConfigure(handle, format);
736    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
737
738    encoderDemo->NativeReset(handle);
739    OH_AVFormat_SetFloatValue(format, OH_MD_KEY_BITRATE, 0.1);
740    ret = encoderDemo->NativeConfigure(handle, format);
741    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
742
743    encoderDemo->NativeReset(handle);
744    OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_BITRATE, 0.1);
745    ret = encoderDemo->NativeConfigure(handle, format);
746    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
747
748    uint8_t a[100];
749    encoderDemo->NativeReset(handle);
750    OH_AVFormat_SetBuffer(format, OH_MD_KEY_BITRATE, a, 100);
751    ret = encoderDemo->NativeConfigure(handle, format);
752    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
753
754    OH_AVFormat_Destroy(format);
755    encoderDemo->NativeDestroy(handle);
756    delete encoderDemo;
757}
758
759
760/**
761 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_015
762 * @tc.name      : OH_AudioEncoder_SetParameter - format(FLAC OH_MD_KEY_AUD_CHANNEL_COUNT) check
763 * @tc.desc      : param check test
764 */
765HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_015, TestSize.Level2)
766{
767    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
768    OH_AVCodec* handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.Flac");
769    ASSERT_NE(nullptr, handle);
770
771    OH_AVFormat* format = OH_AVFormat_Create();
772    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT_FLAC);
773    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE_FLAC);
774    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
775    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
776    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
777    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, BITS_RATE_FLAC);
778
779    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
780    ASSERT_EQ(AV_ERR_OK, ret);
781
782    encoderDemo->NativeReset(handle);
783    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, -1);
784    ret = encoderDemo->NativeConfigure(handle, format);
785    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
786
787    encoderDemo->NativeReset(handle);
788    OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, "aaa");
789    ret = encoderDemo->NativeConfigure(handle, format);
790    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
791
792    encoderDemo->NativeReset(handle);
793    OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0);
794    ret = encoderDemo->NativeConfigure(handle, format);
795    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
796
797    encoderDemo->NativeReset(handle);
798    OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
799    ret = encoderDemo->NativeConfigure(handle, format);
800    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
801
802    encoderDemo->NativeReset(handle);
803    OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
804    ret = encoderDemo->NativeConfigure(handle, format);
805    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
806
807    uint8_t a[100];
808    encoderDemo->NativeReset(handle);
809    OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_CHANNEL_COUNT, a, 100);
810    ret = encoderDemo->NativeConfigure(handle, format);
811    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
812
813    OH_AVFormat_Destroy(format);
814    encoderDemo->NativeDestroy(handle);
815    delete encoderDemo;
816}
817
818/**
819 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_016
820 * @tc.name      : OH_AudioEncoder_SetParameter - format(FLAC OH_MD_KEY_AUD_SAMPLE_RATE) check
821 * @tc.desc      : param check test
822 */
823HWTEST_F(NativeParamCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_PARAM_CHECK_016, TestSize.Level2)
824{
825    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
826    OH_AVCodec* handle = encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.Flac");
827    ASSERT_NE(nullptr, handle);
828
829    OH_AVFormat* format = OH_AVFormat_Create();
830    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT_FLAC);
831    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE_FLAC);
832    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
833    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
834    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
835    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, BITS_RATE_FLAC);
836
837    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
838    ASSERT_EQ(AV_ERR_OK, ret);
839
840    encoderDemo->NativeReset(handle);
841    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, -1);
842    ret = encoderDemo->NativeConfigure(handle, format);
843    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
844
845    encoderDemo->NativeReset(handle);
846    OH_AVFormat_SetStringValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, "aaa");
847    ret = encoderDemo->NativeConfigure(handle, format);
848    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
849
850    encoderDemo->NativeReset(handle);
851    OH_AVFormat_SetLongValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0);
852    ret = encoderDemo->NativeConfigure(handle, format);
853    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
854
855    encoderDemo->NativeReset(handle);
856    OH_AVFormat_SetFloatValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
857    ret = encoderDemo->NativeConfigure(handle, format);
858    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
859
860    encoderDemo->NativeReset(handle);
861    OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
862    ret = encoderDemo->NativeConfigure(handle, format);
863    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
864
865    uint8_t a[100];
866    encoderDemo->NativeReset(handle);
867    OH_AVFormat_SetBuffer(format, OH_MD_KEY_AUD_SAMPLE_RATE, a, 100);
868    ret = encoderDemo->NativeConfigure(handle, format);
869    ASSERT_EQ(AV_ERR_UNSUPPORT, ret);
870
871    OH_AVFormat_Destroy(format);
872    encoderDemo->NativeDestroy(handle);
873    delete encoderDemo;
874}