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
21 using namespace std;
22 using namespace testing::ext;
23 using namespace OHOS;
24 using namespace OHOS::MediaAVCodec;
25
26 namespace {
27 class NativeAVMuxerParamCheckTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp() override;
32 void TearDown() override;
33 };
34
SetUpTestCase()35 void NativeAVMuxerParamCheckTest::SetUpTestCase() {}
TearDownTestCase()36 void NativeAVMuxerParamCheckTest::TearDownTestCase() {}
SetUp()37 void NativeAVMuxerParamCheckTest::SetUp() {}
TearDown()38 void NativeAVMuxerParamCheckTest::TearDown() {}
39
40 constexpr int32_t ROTATION_0 = 0;
41 constexpr int32_t ROTATION_90 = 90;
42 constexpr int32_t ROTATION_180 = 180;
43 constexpr int32_t ROTATION_270 = 270;
44 constexpr int32_t ROTATION_ERROR = -90;
45 constexpr int32_t ROTATION_45 = 45;
46
47 constexpr int64_t AUDIO_BITRATE = 320000;
48 constexpr int64_t VIDEO_BITRATE = 524569;
49 constexpr int32_t CODEC_CONFIG = 100;
50 constexpr int32_t CHANNEL_COUNT = 1;
51 constexpr int32_t SAMPLE_RATE = 48000;
52 constexpr int32_t PROFILE = 0;
53 constexpr int32_t INFO_SIZE = 100;
54
55 constexpr int32_t WIDTH = 352;
56 constexpr int32_t HEIGHT = 288;
57 constexpr double FRAME_RATE = 60;
58 const 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 */
66 HWTEST_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 */
90 HWTEST_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 */
121 HWTEST_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 */
165 HWTEST_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 */
208 HWTEST_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 */
268 HWTEST_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 */
328 HWTEST_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 */
375 HWTEST_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 */
436 HWTEST_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 */
497 HWTEST_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 */
524 HWTEST_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 */
578 HWTEST_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 */
632 HWTEST_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 */
686 HWTEST_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 */
740 HWTEST_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 */
794 HWTEST_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 */
844 HWTEST_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 */
902 HWTEST_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 */
955 HWTEST_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 */
1009 HWTEST_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 */
1063 HWTEST_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 */
1117 HWTEST_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 */
1171 HWTEST_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 */
1220 HWTEST_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 */
1269 HWTEST_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