• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "plugin_definition.h"
20 #include "avcodec_info.h"
21 #include "avcodec_errors.h"
22 #include "avcodec_common.h"
23 
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::MediaAVCodec;
28 using namespace OHOS::MediaAVCodec::Plugin;
29 using namespace Ffmpeg;
30 
31 namespace {
32     class FFmpegAVMuxerParamCheckTest : public testing::Test {
33     public:
34         static void SetUpTestCase();
35         static void TearDownTestCase();
36         void SetUp() override;
37         void TearDown() override;
38     };
39 
SetUpTestCase()40     void FFmpegAVMuxerParamCheckTest::SetUpTestCase() {}
TearDownTestCase()41     void FFmpegAVMuxerParamCheckTest::TearDownTestCase() {}
SetUp()42     void FFmpegAVMuxerParamCheckTest::SetUp() {}
TearDown()43     void FFmpegAVMuxerParamCheckTest::TearDown() {}
44 }
45 
46 
47 /**
48  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_001
49  * @tc.name      : FFmpegCreate - fd check
50  * @tc.desc      : param check test
51  */
52 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_001, TestSize.Level2)
53 {
54     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
55     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
56     int32_t fd = -1;
57     muxerDemo->FFmpegCreate(fd);
58     Status ret = muxerDemo->FFmpegDestroy();
59     ASSERT_EQ(Status::ERROR_NULL_POINTER, ret);
60 
61     fd = muxerDemo->FFmpeggetFdByMode(format);
62     muxerDemo->FFmpegCreate(fd);
63     ret = muxerDemo->FFmpegDestroy();
64     ASSERT_EQ(Status::OK, ret);
65 
66     delete muxerDemo;
67 }
68 
69 
70 /**
71  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_003
72  * @tc.name      : FFmpegSetRotation - longitude check
73  * @tc.desc      : param check test
74  */
75 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_003, TestSize.Level2)
76 {
77     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
78     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
79     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
80     muxerDemo->FFmpegCreate(fd);
81 
82     int32_t rotation;
83 
84     rotation = 0;
85     Status ret = muxerDemo->FFmpegSetRotation(rotation);
86     ASSERT_EQ(Status::OK, ret);
87 
88     rotation = 90;
89     ret = muxerDemo->FFmpegSetRotation(rotation);
90     ASSERT_EQ(Status::OK, ret);
91 
92     rotation = 180;
93     ret = muxerDemo->FFmpegSetRotation(rotation);
94     ASSERT_EQ(Status::OK, ret);
95 
96     rotation = 270;
97     ret = muxerDemo->FFmpegSetRotation(rotation);
98     ASSERT_EQ(Status::OK, ret);
99 
100     rotation = -90;
101     ret = muxerDemo->FFmpegSetRotation(rotation);
102     ASSERT_EQ(Status::ERROR_INVALID_DATA, ret);
103 
104     rotation = 45;
105     ret = muxerDemo->FFmpegSetRotation(rotation);
106     ASSERT_EQ(Status::ERROR_INVALID_DATA, ret);
107 
108     muxerDemo->FFmpegDestroy();
109     delete muxerDemo;
110 }
111 
112 
113 /*
114  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_004
115  * @tc.name      : FFmpegAddTrack - trackDesc(MD_KEY_CODEC_MIME) check
116  * @tc.desc      : param check test
117  */
118 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_004, TestSize.Level2)
119 {
120     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
121     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
122     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
123     muxerDemo->FFmpegCreate(fd);
124 
125     MediaDescription trackDesc;
126 
127 
128     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
129     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 48000);
130     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
131     Status ret;
132     int32_t trackId;
133     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
134     ASSERT_EQ(Status::OK, ret);
135 
136     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_MPEG);
137     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
138     ASSERT_EQ(Status::OK, ret);
139 
140     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_FLAC);
141     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
142     ASSERT_EQ(Status::OK, ret);
143 
144     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, "aaaaaa");
145     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
146     ASSERT_EQ(Status::ERROR_INVALID_DATA, ret);
147 
148     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, 0);
149     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
150     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
151 
152     trackDesc.PutLongValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, 0);
153     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
154     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
155 
156     trackDesc.PutFloatValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, 0.1);
157     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
158     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
159 
160     trackDesc.PutDoubleValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, 0.1);
161     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
162     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
163 
164     uint8_t b[100];
165     trackDesc.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_MIME, b, 100);
166     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
167     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
168 
169     muxerDemo->FFmpegDestroy();
170     delete muxerDemo;
171 }
172 
173 
174 /**
175  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_005
176  * @tc.name      : FFmpegAddTrack - trackDesc(MD_KEY_CHANNEL_COUNT) check
177  * @tc.desc      : param check test
178  */
179 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_005, TestSize.Level2)
180 {
181     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
182     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
183     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
184     muxerDemo->FFmpegCreate(fd);
185 
186     MediaDescription audioParams;
187     audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
188     audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
189     audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 48000);
190 
191     Status ret;
192     int32_t trackId;
193 
194     ret = muxerDemo->FFmpegAddTrack(trackId, audioParams);
195     ASSERT_EQ(Status::OK, ret);
196 
197     audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, -1);
198     ret = muxerDemo->FFmpegAddTrack(trackId, audioParams);
199     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
200 
201     audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, "aaaaaa");
202     ret = muxerDemo->FFmpegAddTrack(trackId, audioParams);
203     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
204 
205     audioParams.PutLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 0);
206     ret = muxerDemo->FFmpegAddTrack(trackId, audioParams);
207     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
208 
209     audioParams.PutFloatValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 0.1);
210     ret = muxerDemo->FFmpegAddTrack(trackId, audioParams);
211     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
212 
213     audioParams.PutDoubleValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 0.1);
214     ret = muxerDemo->FFmpegAddTrack(trackId, audioParams);
215     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
216 
217     uint8_t b[100];
218     audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, b, 100);
219     ret = muxerDemo->FFmpegAddTrack(trackId, audioParams);
220     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
221 
222     muxerDemo->FFmpegDestroy();
223     delete muxerDemo;
224 }
225 
226 
227 /**
228  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_006
229  * @tc.name      : FFmpegAddTrack - MediaDescription(MD_KEY_SAMPLE_RATE) check
230  * @tc.desc      : param check test
231  */
232 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_006, TestSize.Level2)
233 {
234     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
235     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
236     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
237     muxerDemo->FFmpegCreate(fd);
238 
239     MediaDescription trackDesc;
240     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
241     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
242     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 48000);
243 
244     Status ret;
245     int32_t trackId;
246     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
247     ASSERT_EQ(Status::OK, ret);
248 
249     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, -1);
250     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
251     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
252 
253     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, "aaaaaa");
254     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
255     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
256 
257     trackDesc.PutLongValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 0);
258     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
259     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
260 
261     trackDesc.PutFloatValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 0.1);
262     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
263     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
264 
265     trackDesc.PutDoubleValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 0.1);
266     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
267     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
268 
269     uint8_t b[100];
270     trackDesc.PutBuffer(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, b, 100);
271     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
272     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
273 
274     muxerDemo->FFmpegDestroy();
275     delete muxerDemo;
276 }
277 
278 
279 /**
280  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_007
281  * @tc.name      : FFmpegAddTrack - video trackDesc(MD_KEY_CODEC_MIME) check
282  * @tc.desc      : param check test
283  */
284 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_007, TestSize.Level2)
285 {
286     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
287     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
288     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
289     muxerDemo->FFmpegCreate(fd);
290 
291     MediaDescription trackDesc;
292     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_AVC);
293     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, 352);
294     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, 288);
295 
296     Status ret;
297     int32_t trackId;
298 
299     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
300     ASSERT_EQ(Status::OK, ret);
301 
302     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_MPEG4);
303     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
304     ASSERT_EQ(1, trackId);
305 
306     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::IMAGE_PNG);
307     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
308     ASSERT_EQ(Status::OK, ret);
309 
310     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::IMAGE_BMP);
311     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
312     ASSERT_EQ(Status::OK, ret);
313 
314     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::IMAGE_JPG);
315     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
316     ASSERT_EQ(Status::OK, ret);
317 
318     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_HEVC);
319     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
320     ASSERT_EQ(Status::ERROR_INVALID_DATA, ret);
321 
322     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, 0);
323     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
324     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
325 
326     trackDesc.PutLongValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, 0);
327     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
328     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
329 
330     trackDesc.PutFloatValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, 0.1);
331     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
332     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
333 
334     trackDesc.PutDoubleValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, 0.1);
335     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
336     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
337 
338     uint8_t b[100];
339     trackDesc.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_MIME, b, 100);
340     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
341     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
342 
343     muxerDemo->FFmpegDestroy();
344     delete muxerDemo;
345 }
346 
347 
348 /**
349  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_008
350  * @tc.name      : FFmpegAddTrack - video trackDesc(MD_KEY_WIDTH) check
351  * @tc.desc      : param check test
352  */
353 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_008, TestSize.Level2)
354 {
355     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
356     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
357     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
358     muxerDemo->FFmpegCreate(fd);
359 
360     MediaDescription trackDesc;
361     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_AVC);
362 
363     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, 352);
364     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, 288);
365 
366     Status ret;
367     int32_t trackId;
368 
369     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
370     ASSERT_EQ(Status::OK, ret);
371 
372     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, -1);
373     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
374     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
375 
376     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_WIDTH, "aaa");
377     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
378     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
379 
380     trackDesc.PutLongValue(MediaDescriptionKey::MD_KEY_WIDTH, 0);
381     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
382     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
383 
384     trackDesc.PutFloatValue(MediaDescriptionKey::MD_KEY_WIDTH, 0.1);
385     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
386     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
387 
388     trackDesc.PutDoubleValue(MediaDescriptionKey::MD_KEY_WIDTH, 0.1);
389     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
390     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
391 
392     uint8_t b[100];
393     trackDesc.PutBuffer(MediaDescriptionKey::MD_KEY_WIDTH, b, 100);
394     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
395     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
396 
397     muxerDemo->FFmpegDestroy();
398     delete muxerDemo;
399 }
400 /**
401  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_009
402  * @tc.name      : FFmpegAddTrack - video trackDesc(MD_KEY_HEIGHT) check
403  * @tc.desc      : param check test
404  */
405 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_009, TestSize.Level2)
406 {
407     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
408     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
409     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
410     muxerDemo->FFmpegCreate(fd);
411 
412     MediaDescription trackDesc;
413     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_AVC);
414 
415     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, 352);
416     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, 288);
417 
418     Status ret;
419     int32_t trackId;
420 
421     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
422     ASSERT_EQ(Status::OK, ret);
423 
424     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, -1);
425     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
426     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
427 
428     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_HEIGHT, "aaa");
429     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
430     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
431 
432     trackDesc.PutLongValue(MediaDescriptionKey::MD_KEY_HEIGHT, 0);
433     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
434     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
435 
436     trackDesc.PutFloatValue(MediaDescriptionKey::MD_KEY_HEIGHT, 0.1);
437     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
438     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
439 
440     trackDesc.PutDoubleValue(MediaDescriptionKey::MD_KEY_HEIGHT, 0.1);
441     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
442     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
443 
444     uint8_t b[100];
445     trackDesc.PutBuffer(MediaDescriptionKey::MD_KEY_HEIGHT, b, 100);
446     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
447     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
448 
449     muxerDemo->FFmpegDestroy();
450     delete muxerDemo;
451 }
452 
453 /**
454  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_010
455  * @tc.name      : AddTrack - trackDesc(any key) check
456  * @tc.desc      : param check test
457  */
458 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_010, TestSize.Level2)
459 {
460     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
461     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
462     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
463     muxerDemo->FFmpegCreate(fd);
464 
465     MediaDescription trackDesc;
466     trackDesc.PutStringValue("aaaaa", "bbbbb");
467 
468     Status ret;
469     int32_t trackId;
470 
471     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
472     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
473 
474     muxerDemo->FFmpegDestroy();
475     delete muxerDemo;
476 }
477 
478 /**
479  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_011
480  * @tc.name      : WriteSampleBuffer - trackIndex check
481  * @tc.desc      : param check test
482  */
483 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_011, TestSize.Level2)
484 {
485     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
486     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
487     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
488     muxerDemo->FFmpegCreate(fd);
489 
490     MediaDescription trackDesc;
491     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
492     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
493     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 48000);
494 
495     Status ret;
496     int32_t trackId;
497     trackId = 0;
498     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
499     ASSERT_EQ(Status::OK, ret);
500 
501     ret = muxerDemo->FFmpegStart();
502     ASSERT_EQ(Status::OK, ret);
503 
504     uint8_t data[100];
505 
506     AVCodecBufferInfo info;
507     AVCodecBufferFlag flag;
508     info.presentationTimeUs= 0;
509     info.size = 100;
510     uint32_t trackIndex = 0;
511     flag = AVCODEC_BUFFER_FLAG_NONE;
512     info.offset = 0;
513 
514     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
515     ASSERT_EQ(Status::OK, ret);
516 
517     trackId = -1;
518     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
519     ASSERT_EQ(Status::OK, ret);
520 
521     muxerDemo->FFmpegDestroy();
522     delete muxerDemo;
523 }
524 
525 /**
526  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_012
527  * @tc.name      : FFmpegWriteSampleBuffer - info.presentationTimeUscheck
528  * @tc.desc      : param check test
529  */
530 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_012, TestSize.Level2)
531 {
532     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
533     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
534     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
535     muxerDemo->FFmpegCreate(fd);
536 
537     MediaDescription trackDesc;
538     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
539     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
540     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 48000);
541 
542     Status ret;
543     int32_t trackId;
544 
545     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
546     ASSERT_EQ(Status::OK, ret);
547 
548     ret = muxerDemo->FFmpegStart();
549     ASSERT_EQ(Status::OK, ret);
550 
551     uint8_t data[100];
552 
553     AVCodecBufferInfo info;
554     AVCodecBufferFlag flag;
555     info.presentationTimeUs= 0;
556     info.size = 100;
557     uint32_t trackIndex = 0;
558     flag = AVCODEC_BUFFER_FLAG_NONE;
559     info.offset = 0;
560 
561     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
562     ASSERT_EQ(Status::OK, ret);
563 
564     info.presentationTimeUs= -1;
565     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
566     ASSERT_EQ(Status::OK, ret);
567 
568     muxerDemo->FFmpegDestroy();
569     delete muxerDemo;
570 }
571 
572 
573 /**
574  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_013
575  * @tc.name      : FFmpegWriteSampleBuffer - info.size check
576  * @tc.desc      : param check test
577  */
578 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_013, TestSize.Level2)
579 {
580     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
581     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
582     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
583     muxerDemo->FFmpegCreate(fd);
584 
585     MediaDescription trackDesc;
586     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
587 
588     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
589     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 48000);
590 
591     Status ret;
592     int32_t trackId;
593 
594     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
595     ASSERT_EQ(Status::OK, ret);
596 
597     ret = muxerDemo->FFmpegStart();
598     ASSERT_EQ(Status::OK, ret);
599 
600     uint8_t data[100];
601 
602     AVCodecBufferInfo info;
603     AVCodecBufferFlag flag;
604     info.presentationTimeUs= 0;
605     info.size = 100;
606     uint32_t trackIndex = 0;
607     flag = AVCODEC_BUFFER_FLAG_NONE;
608     info.offset = 0;
609 
610     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
611     ASSERT_EQ(Status::OK, ret);
612 
613     info.size = -1;
614     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
615     ASSERT_EQ(Status::OK, ret);
616 
617     muxerDemo->FFmpegDestroy();
618     delete muxerDemo;
619 }
620 
621 /**
622  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_014
623  * @tc.name      : FFmpegWriteSampleBuffer -  info.trackIndex check
624  * @tc.desc      : param check test
625  */
626 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_014, TestSize.Level2)
627 {
628     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
629     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
630     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
631     muxerDemo->FFmpegCreate(fd);
632 
633     MediaDescription trackDesc;
634     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
635 
636     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
637     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 48000);
638 
639 
640     Status ret;
641     int32_t trackId;
642 
643     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
644     ASSERT_EQ(Status::OK, ret);
645 
646     ret = muxerDemo->FFmpegStart();
647     ASSERT_EQ(Status::OK, ret);
648 
649     uint8_t data[100];
650 
651     AVCodecBufferInfo info;
652     AVCodecBufferFlag flag;
653     info.presentationTimeUs= 0;
654     info.size = 100;
655     uint32_t trackIndex = 0;
656     flag = AVCODEC_BUFFER_FLAG_NONE;
657     info.offset = 0;
658 
659     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
660     ASSERT_EQ(Status::OK, ret);
661 
662     info.offset = -1;
663     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
664     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
665 
666     muxerDemo->FFmpegDestroy();
667     delete muxerDemo;
668 }
669 
670 
671 /**
672  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_015
673  * @tc.name      : FFmpegWriteSampleBuffer - flag check
674  * @tc.desc      : param check test
675  */
676 HWTEST_F(FFmpegAVMuxerParamCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_PARAM_CHECK_015, TestSize.Level2)
677 {
678     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
679     OutputFormat format = OUTPUT_FORMAT_MPEG_4;
680     int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
681     muxerDemo->FFmpegCreate(fd);
682 
683     MediaDescription trackDesc;
684     trackDesc.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
685 
686     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
687     trackDesc.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, 48000);
688 
689 
690     Status ret;
691     int32_t trackId;
692 
693     ret = muxerDemo->FFmpegAddTrack(trackId, trackDesc);
694     ASSERT_EQ(Status::OK, ret);
695 
696     ret = muxerDemo->FFmpegStart();
697     ASSERT_EQ(Status::OK, ret);
698 
699     uint8_t data[100];
700 
701     AVCodecBufferInfo info;
702     AVCodecBufferFlag flag;
703     info.presentationTimeUs= 0;
704     info.size = 100;
705     uint32_t trackIndex = 0;
706     flag = AVCODEC_BUFFER_FLAG_NONE;
707     info.offset = 0;
708 
709     ret = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
710     ASSERT_EQ(Status::OK, ret);
711 
712     muxerDemo->FFmpegDestroy();
713     delete muxerDemo;
714 }
715