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 "AVMuxerDemo.h"
19#include "native_avbuffer.h"
20
21using namespace std;
22using namespace testing::ext;
23using namespace OHOS;
24using namespace OHOS::MediaAVCodec;
25
26namespace {
27class NativeAVMuxerParamCheckTest : public testing::Test {
28public:
29    static void SetUpTestCase();
30    static void TearDownTestCase();
31    void SetUp() override;
32    void TearDown() override;
33};
34
35void NativeAVMuxerParamCheckTest::SetUpTestCase() {}
36void NativeAVMuxerParamCheckTest::TearDownTestCase() {}
37void NativeAVMuxerParamCheckTest::SetUp() {}
38void NativeAVMuxerParamCheckTest::TearDown() {}
39
40constexpr int32_t ROTATION_0 = 0;
41constexpr int32_t ROTATION_90 = 90;
42constexpr int32_t ROTATION_180 = 180;
43constexpr int32_t ROTATION_270 = 270;
44constexpr int32_t ROTATION_ERROR = -90;
45constexpr int32_t ROTATION_45 = 45;
46
47constexpr int64_t AUDIO_BITRATE = 320000;
48constexpr int64_t VIDEO_BITRATE = 524569;
49constexpr int32_t CODEC_CONFIG = 100;
50constexpr int32_t CHANNEL_COUNT = 1;
51constexpr int32_t SAMPLE_RATE = 48000;
52constexpr int32_t PROFILE = 0;
53constexpr int32_t INFO_SIZE = 100;
54
55constexpr int32_t WIDTH = 352;
56constexpr int32_t HEIGHT = 288;
57constexpr double FRAME_RATE = 60;
58const std::string HEVC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_hevc_parser.z.so";
59} // namespace
60
61/**
62 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_001
63 * @tc.name      : OH_AVMuxer_Create - fd check
64 * @tc.desc      : param check test
65 */
66HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_001, TestSize.Level2)
67{
68    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
69    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_M4A;
70    int32_t fd = -1;
71    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
72    ASSERT_EQ(nullptr, handle);
73
74    fd = muxerDemo->GetErrorFd();
75    handle = muxerDemo->NativeCreate(fd, format);
76    ASSERT_EQ(nullptr, handle);
77
78    fd = muxerDemo->GetFdByMode(format);
79    handle = muxerDemo->NativeCreate(fd, format);
80    ASSERT_NE(nullptr, handle);
81    muxerDemo->NativeDestroy(handle);
82    delete muxerDemo;
83}
84
85/**
86 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_002
87 * @tc.name      : OH_AVMuxer_Create - format check
88 * @tc.desc      : param check test
89 */
90HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_002, TestSize.Level2)
91{
92    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
93    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_DEFAULT;
94    int32_t fd = muxerDemo->GetFdByMode(format);
95    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
96    ASSERT_NE(nullptr, handle);
97    muxerDemo->NativeDestroy(handle);
98    handle = nullptr;
99
100    format = AV_OUTPUT_FORMAT_MPEG_4;
101    fd = muxerDemo->GetFdByMode(format);
102    handle = muxerDemo->NativeCreate(fd, format);
103    ASSERT_NE(nullptr, handle);
104    muxerDemo->NativeDestroy(handle);
105    handle = nullptr;
106
107    format = AV_OUTPUT_FORMAT_M4A;
108    fd = muxerDemo->GetFdByMode(format);
109    handle = muxerDemo->NativeCreate(fd, format);
110    ASSERT_NE(nullptr, handle);
111    muxerDemo->NativeDestroy(handle);
112    handle = nullptr;
113    delete muxerDemo;
114}
115
116/**
117 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_003
118 * @tc.name      : OH_AVMuxer_SetRotation - rotation check
119 * @tc.desc      : param check test
120 */
121HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_003, TestSize.Level2)
122{
123    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
124    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
125    int32_t fd = muxerDemo->GetFdByMode(format);
126    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
127    ASSERT_NE(nullptr, handle);
128
129    int32_t rotation;
130
131    rotation = ROTATION_0;
132    OH_AVErrCode ret = muxerDemo->NativeSetRotation(handle, rotation);
133    ASSERT_EQ(AV_ERR_OK, ret);
134
135    rotation = ROTATION_90;
136    ret = muxerDemo->NativeSetRotation(handle, rotation);
137    ASSERT_EQ(AV_ERR_OK, ret);
138
139    rotation = ROTATION_180;
140    ret = muxerDemo->NativeSetRotation(handle, rotation);
141    ASSERT_EQ(AV_ERR_OK, ret);
142
143    rotation = ROTATION_270;
144    ret = muxerDemo->NativeSetRotation(handle, rotation);
145    ASSERT_EQ(AV_ERR_OK, ret);
146
147    rotation = ROTATION_ERROR;
148    ret = muxerDemo->NativeSetRotation(handle, rotation);
149    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
150
151    rotation = ROTATION_45;
152    ret = muxerDemo->NativeSetRotation(handle, rotation);
153    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
154
155    muxerDemo->NativeDestroy(handle);
156    handle = nullptr;
157    delete muxerDemo;
158}
159
160/**
161 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_004
162 * @tc.name      : OH_AVMuxer_AddTrack - trackFormat(OH_MD_KEY_CODEC_MIME) check
163 * @tc.desc      : param check test
164 */
165HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_004, TestSize.Level2)
166{
167    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
168    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
169    int32_t fd = muxerDemo->GetFdByMode(format);
170    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
171    ASSERT_NE(nullptr, handle);
172
173    uint8_t a[CODEC_CONFIG];
174
175    OH_AVFormat *trackFormat = OH_AVFormat_Create();
176    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
177    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
178    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
179    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
180    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
181    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
182    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
183
184    int32_t trackId;
185
186    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
187    ASSERT_EQ(0, trackId);
188
189    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
190    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
191    ASSERT_EQ(1, trackId);
192
193    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, "aaaaaa");
194    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
195    ASSERT_NE(AV_ERR_OK, ret);
196
197    muxerDemo->NativeDestroy(handle);
198    OH_AVFormat_Destroy(trackFormat);
199    handle = nullptr;
200    delete muxerDemo;
201}
202
203/**
204 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_005
205 * @tc.name      : OH_AVMuxer_AddTrack - trackFormat(OH_MD_KEY_AUD_CHANNEL_COUNT) check
206 * @tc.desc      : param check test
207 */
208HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_005, TestSize.Level2)
209{
210    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
211    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
212    int32_t fd = muxerDemo->GetFdByMode(format);
213    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
214    ASSERT_NE(nullptr, handle);
215
216    uint8_t a[CODEC_CONFIG];
217
218    OH_AVFormat *trackFormat = OH_AVFormat_Create();
219    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
220    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
221    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
222    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
223    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
224    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
225    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
226
227    int32_t trackId;
228
229    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
230    ASSERT_EQ(0, trackId);
231
232    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, -1);
233    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
234    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
235
236    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, "aaaaaa");
237    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
238    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
239
240    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, 0);
241    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
242    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
243
244    OH_AVFormat_SetFloatValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
245    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
246    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
247
248    OH_AVFormat_SetDoubleValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, 0.1);
249    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
250    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
251
252    uint8_t b[100];
253    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, b, 100);
254    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
255    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
256
257    muxerDemo->NativeDestroy(handle);
258    OH_AVFormat_Destroy(trackFormat);
259    handle = nullptr;
260    delete muxerDemo;
261}
262
263/**
264 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_006
265 * @tc.name      : OH_AVMuxer_AddTrack - trackFormat(OH_MD_KEY_AUD_SAMPLE_RATE) check
266 * @tc.desc      : param check test
267 */
268HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_006, TestSize.Level2)
269{
270    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
271    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
272    int32_t fd = muxerDemo->GetFdByMode(format);
273    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
274    ASSERT_NE(nullptr, handle);
275
276    uint8_t a[CODEC_CONFIG];
277
278    OH_AVFormat *trackFormat = OH_AVFormat_Create();
279    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
280    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
281    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
282    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
283    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
284    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
285    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
286
287    int32_t trackId;
288
289    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
290    ASSERT_EQ(0, trackId);
291
292    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, -1);
293    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
294    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
295
296    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, "aaaaaa");
297    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
298    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
299
300    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, 0);
301    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
302    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
303
304    OH_AVFormat_SetFloatValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
305    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
306    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
307
308    OH_AVFormat_SetDoubleValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, 0.1);
309    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
310    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
311
312    uint8_t b[100];
313    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, b, 100);
314    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
315    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
316
317    muxerDemo->NativeDestroy(handle);
318    OH_AVFormat_Destroy(trackFormat);
319    handle = nullptr;
320    delete muxerDemo;
321}
322
323/**
324 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_007
325 * @tc.name      : OH_AVMuxer_AddTrack - video trackFormat(OH_MD_KEY_CODEC_MIME) check
326 * @tc.desc      : param check test
327 */
328HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_007, TestSize.Level2)
329{
330    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
331    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
332    int32_t fd = muxerDemo->GetFdByMode(format);
333    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
334    ASSERT_NE(nullptr, handle);
335
336    uint8_t a[CODEC_CONFIG];
337
338    OH_AVFormat *trackFormat = OH_AVFormat_Create();
339    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_VIDEO_AVC);
340    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, VIDEO_BITRATE);
341    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
342    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
343    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_WIDTH, WIDTH);
344    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_HEIGHT, HEIGHT);
345
346    int32_t trackId;
347
348    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
349    ASSERT_EQ(AV_ERR_OK, ret);
350    ASSERT_EQ(0, trackId);
351
352    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_VIDEO_MPEG4);
353    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
354    ASSERT_EQ(AV_ERR_OK, ret);
355    ASSERT_EQ(1, trackId);
356
357    if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
358        OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
359        ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
360        ASSERT_EQ(AV_ERR_OK, ret);
361        ASSERT_EQ(2, trackId);
362    }
363
364    muxerDemo->NativeDestroy(handle);
365    OH_AVFormat_Destroy(trackFormat);
366    handle = nullptr;
367    delete muxerDemo;
368}
369
370/**
371 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_008
372 * @tc.name      : OH_AVMuxer_AddTrack - video trackFormat(OH_MD_KEY_WIDTH) check
373 * @tc.desc      : param check test
374 */
375HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_008, TestSize.Level2)
376{
377    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
378    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
379    int32_t fd = muxerDemo->GetFdByMode(format);
380    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
381    ASSERT_NE(nullptr, handle);
382
383    uint8_t a[CODEC_CONFIG];
384
385    OH_AVFormat *trackFormat = OH_AVFormat_Create();
386    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_VIDEO_AVC);
387    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, 524569);
388    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
389    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
390    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_WIDTH, WIDTH);
391    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_HEIGHT, HEIGHT);
392    OH_AVFormat_SetDoubleValue(trackFormat, OH_MD_KEY_FRAME_RATE, FRAME_RATE);
393    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
394
395    int32_t trackId;
396
397    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
398    ASSERT_EQ(0, trackId);
399
400    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_WIDTH, -1);
401    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
402    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
403
404    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_WIDTH, "aaa");
405    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
406    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
407
408    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_WIDTH, 0);
409    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
410    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
411
412    OH_AVFormat_SetFloatValue(trackFormat, OH_MD_KEY_WIDTH, 0.1);
413    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
414    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
415
416    OH_AVFormat_SetDoubleValue(trackFormat, OH_MD_KEY_WIDTH, 0.1);
417    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
418    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
419
420    uint8_t b[100];
421    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_WIDTH, b, 100);
422    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
423    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
424
425    muxerDemo->NativeDestroy(handle);
426    OH_AVFormat_Destroy(trackFormat);
427    handle = nullptr;
428    delete muxerDemo;
429}
430
431/**
432 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_009
433 * @tc.name      : OH_AVMuxer_AddTrack - video trackFormat(OH_MD_KEY_HEIGHT) check
434 * @tc.desc      : param check test
435 */
436HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_009, TestSize.Level2)
437{
438    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
439    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
440    int32_t fd = muxerDemo->GetFdByMode(format);
441    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
442    ASSERT_NE(nullptr, handle);
443
444    uint8_t a[CODEC_CONFIG];
445
446    OH_AVFormat *trackFormat = OH_AVFormat_Create();
447    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_VIDEO_AVC);
448    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, 524569);
449    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
450    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
451    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_WIDTH, WIDTH);
452    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_HEIGHT, HEIGHT);
453    OH_AVFormat_SetDoubleValue(trackFormat, OH_MD_KEY_FRAME_RATE, FRAME_RATE);
454    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
455
456    int32_t trackId;
457
458    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
459    ASSERT_EQ(0, trackId);
460
461    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_HEIGHT, -1);
462    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
463    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
464
465    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_HEIGHT, "aaa");
466    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
467    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
468
469    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_HEIGHT, 0);
470    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
471    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
472
473    OH_AVFormat_SetFloatValue(trackFormat, OH_MD_KEY_HEIGHT, 0.1);
474    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
475    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
476
477    OH_AVFormat_SetDoubleValue(trackFormat, OH_MD_KEY_HEIGHT, 0.1);
478    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
479    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
480
481    uint8_t b[100];
482    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_HEIGHT, b, 100);
483    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
484    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
485
486    muxerDemo->NativeDestroy(handle);
487    OH_AVFormat_Destroy(trackFormat);
488    handle = nullptr;
489    delete muxerDemo;
490}
491
492/**
493 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_010
494 * @tc.name      : OH_AVMuxer_AddTrack - trackFormat(any key) check
495 * @tc.desc      : param check test
496 */
497HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_010, TestSize.Level2)
498{
499    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
500    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
501    int32_t fd = muxerDemo->GetFdByMode(format);
502    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
503    ASSERT_NE(nullptr, handle);
504
505    OH_AVFormat *trackFormat = OH_AVFormat_Create();
506    OH_AVFormat_SetStringValue(trackFormat, "aaaaa", "bbbbb");
507
508    int32_t trackId;
509
510    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
511    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
512
513    muxerDemo->NativeDestroy(handle);
514    OH_AVFormat_Destroy(trackFormat);
515    handle = nullptr;
516    delete muxerDemo;
517}
518
519/**
520 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_011
521 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - trackIndex check
522 * @tc.desc      : param check test
523 */
524HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_011, TestSize.Level2)
525{
526    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
527    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
528    int32_t fd = muxerDemo->GetFdByMode(format);
529    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
530    ASSERT_NE(nullptr, handle);
531
532    uint8_t a[CODEC_CONFIG];
533
534    OH_AVFormat *trackFormat = OH_AVFormat_Create();
535    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
536    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
537    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
538    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
539    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
540    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
541    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
542
543    int32_t trackId;
544
545    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
546    ASSERT_EQ(0, trackId);
547
548    ret = muxerDemo->NativeStart(handle);
549    ASSERT_EQ(AV_ERR_OK, ret);
550
551    OH_AVMemory *avMemBuffer = OH_AVMemory_Create(INFO_SIZE);
552
553    OH_AVCodecBufferAttr info;
554    info.pts = 0;
555    info.size = INFO_SIZE;
556    info.offset = 0;
557    info.flags = 0;
558
559    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
560    ASSERT_EQ(AV_ERR_OK, ret);
561
562    trackId = -1;
563    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
564    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
565
566    OH_AVMemory_Destroy(avMemBuffer);
567    muxerDemo->NativeDestroy(handle);
568    OH_AVFormat_Destroy(trackFormat);
569    handle = nullptr;
570    delete muxerDemo;
571}
572
573/**
574 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_012
575 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - info.pts check
576 * @tc.desc      : param check test
577 */
578HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_012, TestSize.Level2)
579{
580    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
581    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
582    int32_t fd = muxerDemo->GetFdByMode(format);
583    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
584    ASSERT_NE(nullptr, handle);
585
586    uint8_t a[CODEC_CONFIG];
587
588    OH_AVFormat *trackFormat = OH_AVFormat_Create();
589    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
590    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
591    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
592    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
593    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
594    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
595    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
596
597    int32_t trackId;
598
599    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
600    ASSERT_EQ(0, trackId);
601
602    ret = muxerDemo->NativeStart(handle);
603    ASSERT_EQ(AV_ERR_OK, ret);
604
605    OH_AVMemory *avMemBuffer = OH_AVMemory_Create(INFO_SIZE);
606
607    OH_AVCodecBufferAttr info;
608    info.pts = 0;
609    info.size = INFO_SIZE;
610    info.offset = 0;
611    info.flags = 0;
612
613    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
614    ASSERT_EQ(AV_ERR_OK, ret);
615
616    info.pts = -1;
617    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
618    ASSERT_EQ(AV_ERR_OK, ret);
619
620    OH_AVMemory_Destroy(avMemBuffer);
621    muxerDemo->NativeDestroy(handle);
622    OH_AVFormat_Destroy(trackFormat);
623    handle = nullptr;
624    delete muxerDemo;
625}
626
627/**
628 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_013
629 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - info.size check
630 * @tc.desc      : param check test
631 */
632HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_013, TestSize.Level2)
633{
634    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
635    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
636    int32_t fd = muxerDemo->GetFdByMode(format);
637    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
638    ASSERT_NE(nullptr, handle);
639
640    uint8_t a[CODEC_CONFIG];
641
642    OH_AVFormat *trackFormat = OH_AVFormat_Create();
643    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
644    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
645    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
646    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
647    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
648    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
649    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
650
651    int32_t trackId;
652
653    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
654    ASSERT_EQ(0, trackId);
655
656    ret = muxerDemo->NativeStart(handle);
657    ASSERT_EQ(AV_ERR_OK, ret);
658
659    OH_AVMemory *avMemBuffer = OH_AVMemory_Create(INFO_SIZE);
660
661    OH_AVCodecBufferAttr info;
662    info.pts = 0;
663    info.size = INFO_SIZE;
664    info.offset = 0;
665    info.flags = 0;
666
667    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
668    ASSERT_EQ(AV_ERR_OK, ret);
669
670    info.size = -1;
671    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
672    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
673
674    OH_AVMemory_Destroy(avMemBuffer);
675    muxerDemo->NativeDestroy(handle);
676    OH_AVFormat_Destroy(trackFormat);
677    handle = nullptr;
678    delete muxerDemo;
679}
680
681/**
682 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_014
683 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - info.offset check
684 * @tc.desc      : param check test
685 */
686HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_014, TestSize.Level2)
687{
688    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
689    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
690    int32_t fd = muxerDemo->GetFdByMode(format);
691    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
692    ASSERT_NE(nullptr, handle);
693
694    uint8_t a[CODEC_CONFIG];
695
696    OH_AVFormat *trackFormat = OH_AVFormat_Create();
697    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
698    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
699    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
700    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
701    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
702    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
703    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
704
705    int32_t trackId;
706
707    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
708    ASSERT_EQ(0, trackId);
709
710    ret = muxerDemo->NativeStart(handle);
711    ASSERT_EQ(AV_ERR_OK, ret);
712
713    OH_AVMemory *avMemBuffer = OH_AVMemory_Create(INFO_SIZE);
714
715    OH_AVCodecBufferAttr info;
716    info.pts = 0;
717    info.size = INFO_SIZE;
718    info.offset = 0;
719    info.flags = 0;
720
721    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
722    ASSERT_EQ(AV_ERR_OK, ret);
723
724    info.offset = -1;
725    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
726    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
727
728    OH_AVMemory_Destroy(avMemBuffer);
729    muxerDemo->NativeDestroy(handle);
730    OH_AVFormat_Destroy(trackFormat);
731    handle = nullptr;
732    delete muxerDemo;
733}
734
735/**
736 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_015
737 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - info.flags check
738 * @tc.desc      : param check test
739 */
740HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_015, TestSize.Level2)
741{
742    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
743    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
744    int32_t fd = muxerDemo->GetFdByMode(format);
745    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
746    ASSERT_NE(nullptr, handle);
747
748    uint8_t a[CODEC_CONFIG];
749
750    OH_AVFormat *trackFormat = OH_AVFormat_Create();
751    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
752    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
753    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
754    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
755    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
756    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
757    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
758
759    int32_t trackId;
760
761    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
762    ASSERT_EQ(0, trackId);
763
764    ret = muxerDemo->NativeStart(handle);
765    ASSERT_EQ(AV_ERR_OK, ret);
766
767    OH_AVMemory *avMemBuffer = OH_AVMemory_Create(INFO_SIZE);
768
769    OH_AVCodecBufferAttr info;
770    info.pts = 0;
771    info.size = INFO_SIZE;
772    info.offset = 0;
773    info.flags = 0;
774
775    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
776    ASSERT_EQ(AV_ERR_OK, ret);
777
778    info.flags = -1;
779    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
780    ASSERT_EQ(AV_ERR_OK, ret);
781
782    OH_AVMemory_Destroy(avMemBuffer);
783    muxerDemo->NativeDestroy(handle);
784    OH_AVFormat_Destroy(trackFormat);
785    handle = nullptr;
786    delete muxerDemo;
787}
788
789/**
790 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_016
791 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - sample check
792 * @tc.desc      : param check test
793 */
794HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_016, TestSize.Level2)
795{
796    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
797    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
798    int32_t fd = muxerDemo->GetFdByMode(format);
799    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
800    ASSERT_NE(nullptr, handle);
801
802    uint8_t a[CODEC_CONFIG];
803
804    OH_AVFormat *trackFormat = OH_AVFormat_Create();
805    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
806    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
807    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
808    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
809    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
810    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
811    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
812
813    int32_t trackId;
814
815    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
816    ASSERT_EQ(0, trackId);
817
818    ret = muxerDemo->NativeStart(handle);
819    ASSERT_EQ(AV_ERR_OK, ret);
820
821    OH_AVMemory *avMemBuffer = OH_AVMemory_Create(10);
822
823    OH_AVCodecBufferAttr info;
824    info.pts = 0;
825    info.size = INFO_SIZE;
826    info.offset = 0;
827    info.flags = 0;
828
829    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avMemBuffer, info);
830    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
831
832    OH_AVMemory_Destroy(avMemBuffer);
833    muxerDemo->NativeDestroy(handle);
834    OH_AVFormat_Destroy(trackFormat);
835    handle = nullptr;
836    delete muxerDemo;
837}
838
839/**
840 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_017
841 * @tc.name      : OH_AVMuxer_AddTrack - video trackFormat(OH_MD_KEY_COLOR_PRIMARIES) check
842 * @tc.desc      : param check test
843 */
844HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_017, TestSize.Level2)
845{
846    if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
847        std::cout << "the hevc of mimetype is not supported" << std::endl;
848        return;
849    }
850    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
851    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
852    int32_t fd = muxerDemo->GetFdByMode(format);
853    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
854    ASSERT_NE(nullptr, handle);
855    uint8_t a[CODEC_CONFIG];
856    OH_AVFormat *trackFormat = OH_AVFormat_Create();
857    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
858    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, 524569);
859    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
860    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_WIDTH, WIDTH);
861    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_HEIGHT, HEIGHT);
862    OH_AVFormat_SetDoubleValue(trackFormat, OH_MD_KEY_FRAME_RATE, FRAME_RATE);
863    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_COLOR_PRIMARIES, OH_ColorPrimary::COLOR_PRIMARY_BT709);
864    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_TRANSFER_CHARACTERISTICS,
865        OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_BT709);
866    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_MATRIX_COEFFICIENTS,
867        OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT709);
868    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_RANGE_FLAG, 0);
869    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_VIDEO_IS_HDR_VIVID, 1);
870    int32_t trackId;
871    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
872    ASSERT_EQ(0, trackId);
873    ASSERT_EQ(AV_ERR_OK, ret);
874    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_COLOR_PRIMARIES, 0);
875    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
876    ASSERT_NE(AV_ERR_OK, ret);
877    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_COLOR_PRIMARIES, OH_ColorPrimary::COLOR_PRIMARY_BT709);
878    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_TRANSFER_CHARACTERISTICS, 0);
879    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
880    ASSERT_NE(AV_ERR_OK, ret);
881    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_TRANSFER_CHARACTERISTICS,
882        OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_BT709);
883    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_MATRIX_COEFFICIENTS, 3);
884    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
885    ASSERT_NE(AV_ERR_OK, ret);
886    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_MATRIX_COEFFICIENTS,
887        OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT709);
888    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_VIDEO_IS_HDR_VIVID, 0);
889    ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
890    ASSERT_EQ(AV_ERR_OK, ret);
891    muxerDemo->NativeDestroy(handle);
892    OH_AVFormat_Destroy(trackFormat);
893    delete muxerDemo;
894}
895
896
897/**
898 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_018
899 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - trackIndex check
900 * @tc.desc      : param check test
901 */
902HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_018, TestSize.Level2)
903{
904    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
905    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
906    int32_t fd = muxerDemo->GetFdByMode(format);
907    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
908    ASSERT_NE(nullptr, handle);
909
910    uint8_t a[CODEC_CONFIG];
911
912    OH_AVFormat *trackFormat = OH_AVFormat_Create();
913    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
914    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
915    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
916    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
917    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
918    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
919
920    int32_t trackId;
921
922    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
923    ASSERT_EQ(0, trackId);
924
925    ret = muxerDemo->NativeStart(handle);
926    ASSERT_EQ(AV_ERR_OK, ret);
927
928    OH_AVBuffer *avBuffer = OH_AVBuffer_Create(INFO_SIZE);
929
930    OH_AVCodecBufferAttr info;
931    info.pts = 0;
932    info.size = INFO_SIZE;
933    info.offset = 0;
934    info.flags = 0;
935    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
936    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
937    ASSERT_EQ(AV_ERR_OK, ret);
938
939    trackId = -1;
940    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
941    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
942
943    OH_AVBuffer_Destroy(avBuffer);
944    muxerDemo->NativeDestroy(handle);
945    OH_AVFormat_Destroy(trackFormat);
946    handle = nullptr;
947    delete muxerDemo;
948}
949
950/**
951 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_019
952 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - info.pts check
953 * @tc.desc      : param check test
954 */
955HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_019, TestSize.Level2)
956{
957    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
958    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
959    int32_t fd = muxerDemo->GetFdByMode(format);
960    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
961    ASSERT_NE(nullptr, handle);
962
963    uint8_t a[CODEC_CONFIG];
964
965    OH_AVFormat *trackFormat = OH_AVFormat_Create();
966    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
967    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
968    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
969    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
970    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
971    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
972
973    int32_t trackId;
974
975    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
976    ASSERT_EQ(0, trackId);
977
978    ret = muxerDemo->NativeStart(handle);
979    ASSERT_EQ(AV_ERR_OK, ret);
980
981    OH_AVBuffer *avBuffer = OH_AVBuffer_Create(INFO_SIZE);
982
983    OH_AVCodecBufferAttr info;
984    info.pts = 0;
985    info.size = INFO_SIZE;
986    info.offset = 0;
987    info.flags = 0;
988    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
989    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
990    ASSERT_EQ(AV_ERR_OK, ret);
991
992    info.pts = -1;
993    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
994    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
995    ASSERT_EQ(AV_ERR_OK, ret);
996
997    OH_AVBuffer_Destroy(avBuffer);
998    muxerDemo->NativeDestroy(handle);
999    OH_AVFormat_Destroy(trackFormat);
1000    handle = nullptr;
1001    delete muxerDemo;
1002}
1003
1004/**
1005 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_020
1006 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - info.size check
1007 * @tc.desc      : param check test
1008 */
1009HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_020, TestSize.Level2)
1010{
1011    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
1012    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
1013    int32_t fd = muxerDemo->GetFdByMode(format);
1014    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
1015    ASSERT_NE(nullptr, handle);
1016
1017    uint8_t a[CODEC_CONFIG];
1018
1019    OH_AVFormat *trackFormat = OH_AVFormat_Create();
1020    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
1021    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
1022    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
1023    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
1024    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
1025    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
1026
1027    int32_t trackId;
1028
1029    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
1030    ASSERT_EQ(0, trackId);
1031
1032    ret = muxerDemo->NativeStart(handle);
1033    ASSERT_EQ(AV_ERR_OK, ret);
1034
1035    OH_AVBuffer *avBuffer = OH_AVBuffer_Create(INFO_SIZE);
1036
1037    OH_AVCodecBufferAttr info;
1038    info.pts = 0;
1039    info.size = INFO_SIZE;
1040    info.offset = 0;
1041    info.flags = 0;
1042    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1043    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1044    ASSERT_EQ(AV_ERR_OK, ret);
1045
1046    info.size = -1;
1047    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1048    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1049    ASSERT_EQ(AV_ERR_OK, ret);
1050
1051    OH_AVBuffer_Destroy(avBuffer);
1052    muxerDemo->NativeDestroy(handle);
1053    OH_AVFormat_Destroy(trackFormat);
1054    handle = nullptr;
1055    delete muxerDemo;
1056}
1057
1058/**
1059 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_021
1060 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - info.offset check
1061 * @tc.desc      : param check test
1062 */
1063HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_021, TestSize.Level2)
1064{
1065    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
1066    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
1067    int32_t fd = muxerDemo->GetFdByMode(format);
1068    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
1069    ASSERT_NE(nullptr, handle);
1070
1071    uint8_t a[CODEC_CONFIG];
1072
1073    OH_AVFormat *trackFormat = OH_AVFormat_Create();
1074    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
1075    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
1076    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
1077    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
1078    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
1079    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
1080
1081    int32_t trackId;
1082
1083    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
1084    ASSERT_EQ(0, trackId);
1085
1086    ret = muxerDemo->NativeStart(handle);
1087    ASSERT_EQ(AV_ERR_OK, ret);
1088
1089    OH_AVBuffer *avBuffer = OH_AVBuffer_Create(INFO_SIZE);
1090
1091    OH_AVCodecBufferAttr info;
1092    info.pts = 0;
1093    info.size = INFO_SIZE;
1094    info.offset = 0;
1095    info.flags = 0;
1096    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1097    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1098    ASSERT_EQ(AV_ERR_OK, ret);
1099
1100    info.offset = -1;
1101    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1102    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1103    ASSERT_EQ(AV_ERR_OK, ret);
1104
1105    OH_AVBuffer_Destroy(avBuffer);
1106    muxerDemo->NativeDestroy(handle);
1107    OH_AVFormat_Destroy(trackFormat);
1108    handle = nullptr;
1109    delete muxerDemo;
1110}
1111
1112/**
1113 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_022
1114 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - info.flags check
1115 * @tc.desc      : param check test
1116 */
1117HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_022, TestSize.Level2)
1118{
1119    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
1120    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
1121    int32_t fd = muxerDemo->GetFdByMode(format);
1122    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
1123    ASSERT_NE(nullptr, handle);
1124
1125    uint8_t a[CODEC_CONFIG];
1126
1127    OH_AVFormat *trackFormat = OH_AVFormat_Create();
1128    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
1129    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
1130    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
1131    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
1132    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
1133    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
1134
1135    int32_t trackId;
1136
1137    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
1138    ASSERT_EQ(0, trackId);
1139
1140    ret = muxerDemo->NativeStart(handle);
1141    ASSERT_EQ(AV_ERR_OK, ret);
1142
1143    OH_AVBuffer *avBuffer = OH_AVBuffer_Create(INFO_SIZE);
1144
1145    OH_AVCodecBufferAttr info;
1146    info.pts = 0;
1147    info.size = INFO_SIZE;
1148    info.offset = 0;
1149    info.flags = 0;
1150    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1151    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1152    ASSERT_EQ(AV_ERR_OK, ret);
1153
1154    info.flags = -1;
1155    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1156    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1157    ASSERT_EQ(AV_ERR_OK, ret);
1158
1159    OH_AVBuffer_Destroy(avBuffer);
1160    muxerDemo->NativeDestroy(handle);
1161    OH_AVFormat_Destroy(trackFormat);
1162    handle = nullptr;
1163    delete muxerDemo;
1164}
1165
1166/**
1167 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_025
1168 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - sample check
1169 * @tc.desc      : param check test
1170 */
1171HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_025, TestSize.Level2)
1172{
1173    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
1174    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MP3;
1175    int32_t fd = muxerDemo->GetFdByMode(format);
1176    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
1177    ASSERT_NE(nullptr, handle);
1178
1179    uint8_t a[CODEC_CONFIG];
1180
1181    OH_AVFormat *trackFormat = OH_AVFormat_Create();
1182    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_MPEG);
1183    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
1184    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
1185    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
1186    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
1187    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
1188
1189    int32_t trackId;
1190
1191    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
1192    ASSERT_EQ(0, trackId);
1193
1194    ret = muxerDemo->NativeStart(handle);
1195    ASSERT_EQ(AV_ERR_OK, ret);
1196
1197    OH_AVBuffer *avBuffer = OH_AVBuffer_Create(INFO_SIZE);
1198
1199    OH_AVCodecBufferAttr info;
1200    info.pts = 0;
1201    info.size = INFO_SIZE;
1202    info.offset = 0;
1203    info.flags = 0;
1204    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1205    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1206    ASSERT_EQ(AV_ERR_OK, ret);
1207
1208    OH_AVBuffer_Destroy(avBuffer);
1209    muxerDemo->NativeDestroy(handle);
1210    OH_AVFormat_Destroy(trackFormat);
1211    handle = nullptr;
1212    delete muxerDemo;
1213}
1214
1215/**
1216 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_023
1217 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - sample check
1218 * @tc.desc      : param check test
1219 */
1220HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_023, TestSize.Level2)
1221{
1222    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
1223    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_MPEG_4;
1224    int32_t fd = muxerDemo->GetFdByMode(format);
1225    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
1226    ASSERT_NE(nullptr, handle);
1227
1228    uint8_t a[CODEC_CONFIG];
1229
1230    OH_AVFormat *trackFormat = OH_AVFormat_Create();
1231    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
1232    OH_AVFormat_SetLongValue(trackFormat, OH_MD_KEY_BITRATE, AUDIO_BITRATE);
1233    OH_AVFormat_SetBuffer(trackFormat, OH_MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG);
1234    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
1235    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
1236    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_PROFILE, PROFILE);
1237
1238    int32_t trackId;
1239
1240    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
1241    ASSERT_EQ(0, trackId);
1242
1243    ret = muxerDemo->NativeStart(handle);
1244    ASSERT_EQ(AV_ERR_OK, ret);
1245
1246    OH_AVBuffer *avBuffer = OH_AVBuffer_Create(0x10);
1247
1248    OH_AVCodecBufferAttr info;
1249    info.pts = 0;
1250    info.size = INFO_SIZE;
1251    info.offset = 0;
1252    info.flags = 0;
1253    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1254    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1255    ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1256
1257    OH_AVBuffer_Destroy(avBuffer);
1258    muxerDemo->NativeDestroy(handle);
1259    OH_AVFormat_Destroy(trackFormat);
1260    handle = nullptr;
1261    delete muxerDemo;
1262}
1263
1264/**
1265 * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_024
1266 * @tc.name      : OH_AVMuxer_WriteSampleBuffer - sample check
1267 * @tc.desc      : param check test
1268 */
1269HWTEST_F(NativeAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_024, TestSize.Level2)
1270{
1271    AVMuxerDemo *muxerDemo = new AVMuxerDemo();
1272    OH_AVOutputFormat format = AV_OUTPUT_FORMAT_AMR;
1273    int32_t fd = muxerDemo->GetFdByMode(format);
1274    OH_AVMuxer *handle = muxerDemo->NativeCreate(fd, format);
1275    ASSERT_NE(nullptr, handle);
1276
1277    OH_AVFormat *trackFormat = OH_AVFormat_Create();
1278    OH_AVFormat_SetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB);
1279    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, 1); // 1 audio channel, mono
1280    OH_AVFormat_SetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, 8000); // 8000: 8khz sample rate
1281
1282    int32_t trackId;
1283
1284    OH_AVErrCode ret = muxerDemo->NativeAddTrack(handle, &trackId, trackFormat);
1285    ASSERT_EQ(0, trackId);
1286
1287    ret = muxerDemo->NativeStart(handle);
1288    ASSERT_EQ(AV_ERR_OK, ret);
1289
1290    OH_AVBuffer *avBuffer = OH_AVBuffer_Create(INFO_SIZE);
1291
1292    OH_AVCodecBufferAttr info;
1293    info.pts = 0;
1294    info.size = INFO_SIZE;
1295    info.offset = 0;
1296    info.flags = 0;
1297    OH_AVBuffer_SetBufferAttr(avBuffer, &info);
1298    ret = muxerDemo->NativeWriteSampleBuffer(handle, trackId, avBuffer);
1299    ASSERT_EQ(AV_ERR_OK, ret);
1300
1301    OH_AVBuffer_Destroy(avBuffer);
1302    muxerDemo->NativeDestroy(handle);
1303    OH_AVFormat_Destroy(trackFormat);
1304    handle = nullptr;
1305    delete muxerDemo;
1306}
1307