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
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
39 constexpr int32_t CHANNEL_COUNT_FLAC = 2;
40 constexpr int32_t SAMPLE_RATE_FLAC = 48000;
41 constexpr 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 */
49 HWTEST_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 */
71 HWTEST_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 */
94 HWTEST_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 */
153 HWTEST_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 */
212 HWTEST_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 */
271 HWTEST_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 */
332 HWTEST_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 */
393 HWTEST_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 */
454 HWTEST_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 */
505 HWTEST_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 */
558 HWTEST_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 */
611 HWTEST_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 */
664 HWTEST_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 */
706 HWTEST_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 */
765 HWTEST_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 */
823 HWTEST_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 }