• 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 "avcodec_info.h"
20 #include "avcodec_errors.h"
21 
22 using namespace std;
23 using namespace testing::ext;
24 using namespace OHOS;
25 using namespace OHOS::MediaAVCodec;
26 using namespace Plugin;
27 using namespace Ffmpeg;
28 
29 
30 namespace {
31     class FFmpegAVMuxerInterfaceDependCheckTest : public testing::Test {
32     public:
33         static void SetUpTestCase();
34         static void TearDownTestCase();
35         void SetUp() override;
36         void TearDown() override;
37     };
38 
SetUpTestCase()39     void FFmpegAVMuxerInterfaceDependCheckTest::SetUpTestCase() {}
TearDownTestCase()40     void FFmpegAVMuxerInterfaceDependCheckTest::TearDownTestCase() {}
SetUp()41     void FFmpegAVMuxerInterfaceDependCheckTest::SetUp() {}
TearDown()42     void FFmpegAVMuxerInterfaceDependCheckTest::TearDown() {}
43 
Create(AVMuxerDemo * muxerDemo)44     void Create(AVMuxerDemo* muxerDemo)
45     {
46         OutputFormat format = OUTPUT_FORMAT_MPEG_4;
47         int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
48         muxerDemo->FFmpegCreate(fd);
49     }
50 
SetRotation(AVMuxerDemo * muxerDemo)51     Status SetRotation(AVMuxerDemo* muxerDemo)
52     {
53         int32_t rotation = 0;
54 
55         return muxerDemo->FFmpegSetRotation(rotation);
56     }
57 
AddTrack(AVMuxerDemo * muxerDemo,int32_t & trackIndex)58     Status AddTrack(AVMuxerDemo* muxerDemo, int32_t& trackIndex)
59     {
60         MediaDescription audioParams;
61         uint8_t a[100];
62         uint32_t CHANNEL_COUNT = 1;
63         uint32_t SAMPLE_RATE = 48000;
64         uint32_t BITS_RATE = 320000;
65         uint32_t CODEC_CONFIG_SIZE = 100;
66         audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
67         audioParams.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, BITS_RATE);
68         audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, a, CODEC_CONFIG_SIZE);
69         audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
70         audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
71 
72         return muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
73     }
74 
Start(AVMuxerDemo * muxerDemo)75     Status Start(AVMuxerDemo* muxerDemo)
76     {
77         return muxerDemo->FFmpegStart();
78     }
79 
WriteSampleBuffer(AVMuxerDemo * muxerDemo,uint32_t trackIndex)80     Status WriteSampleBuffer(AVMuxerDemo* muxerDemo, uint32_t trackIndex)
81     {
82         uint8_t data[100];
83 
84         AVCodecBufferInfo info;
85         AVCodecBufferFlag flag;
86         uint32_t DEAULT_SIZE = 100;
87         info.size = DEAULT_SIZE;
88         info.presentationTimeUs = 0;
89         flag = AVCODEC_BUFFER_FLAG_NONE;
90         info.offset = 0;
91 
92         return muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
93     }
94 
Stop(AVMuxerDemo * muxerDemo)95     Status Stop(AVMuxerDemo* muxerDemo)
96     {
97         return muxerDemo->FFmpegStop();
98     }
99 
Destroy(AVMuxerDemo * muxerDemo)100     Status Destroy(AVMuxerDemo* muxerDemo)
101     {
102         return muxerDemo->FFmpegDestroy();
103     }
104 }
105 
106 /**
107  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_001
108  * @tc.name      : Create -> SetRotation
109  * @tc.desc      : interface depend check
110  */
111 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_001, TestSize.Level2)
112 {
113     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
114     Create(muxerDemo);
115 
116     Status ret;
117 
118     ret = SetRotation(muxerDemo);
119     ASSERT_EQ(Status::OK, ret);
120 
121     Destroy(muxerDemo);
122     delete muxerDemo;
123 }
124 
125 /**
126  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_002
127  * @tc.name      : Create -> SetRotation -> SetRotation
128  * @tc.desc      : interface depend check
129  */
130 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_002, TestSize.Level2)
131 {
132     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
133     Create(muxerDemo);
134 
135     Status ret;
136 
137     ret = SetRotation(muxerDemo);
138     ASSERT_EQ(Status::OK, ret);
139 
140     ret = SetRotation(muxerDemo);
141     ASSERT_EQ(Status::OK, ret);
142 
143     Destroy(muxerDemo);
144     delete muxerDemo;
145 }
146 
147 /**
148  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_003
149  * @tc.name      : Create -> AddTrack -> SetRotation
150  * @tc.desc      : interface depend check
151  */
152 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_003, TestSize.Level2)
153 {
154     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
155     Create(muxerDemo);
156 
157     Status ret;
158 
159     int32_t trackId;
160     ret = AddTrack(muxerDemo, trackId);
161     ASSERT_EQ(Status::OK, ret);
162     ASSERT_EQ(0, trackId);
163 
164     ret = SetRotation(muxerDemo);
165     ASSERT_EQ(Status::OK, ret);
166 
167     Destroy(muxerDemo);
168     delete muxerDemo;
169 }
170 
171 
172 /**
173  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_004
174  * @tc.name      : Create -> AddTrack -> Start -> SetRotation
175  * @tc.desc      : interface depend check
176  */
177 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_004, TestSize.Level2)
178 {
179     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
180     Create(muxerDemo);
181 
182     Status ret;
183 
184     int32_t trackId;
185     ret = AddTrack(muxerDemo, trackId);
186     ASSERT_EQ(Status::OK, ret);
187     ASSERT_EQ(0, trackId);
188 
189     ret = Start(muxerDemo);
190     ASSERT_EQ(Status::OK, ret);
191 
192     ret = SetRotation(muxerDemo);
193     ASSERT_EQ(Status::OK, ret);
194 
195     Destroy(muxerDemo);
196     delete muxerDemo;
197 }
198 
199 
200 /**
201  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_005
202  * @tc.name      : Create -> AddTrack -> Start -> Stop -> SetRotation
203  * @tc.desc      : interface depend check
204  */
205 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_005, TestSize.Level2)
206 {
207     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
208     Create(muxerDemo);
209 
210     Status ret;
211 
212     int32_t trackId;
213     ret = AddTrack(muxerDemo, trackId);
214     ASSERT_EQ(Status::OK, ret);
215     ASSERT_EQ(0, trackId);
216 
217     ret = Start(muxerDemo);
218     ASSERT_EQ(Status::OK, ret);
219 
220     ret = Stop(muxerDemo);
221     ASSERT_EQ(Status::OK, ret);
222 
223     ret = SetRotation(muxerDemo);
224     ASSERT_EQ(Status::ERROR_MISMATCHED_TYPE, ret);
225 
226     Destroy(muxerDemo);
227     delete muxerDemo;
228 }
229 
230 /**
231  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_006
232  * @tc.name      : Create -> AddTrack
233  * @tc.desc      : interface depend check
234  */
235 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_006, TestSize.Level2)
236 {
237     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
238     Create(muxerDemo);
239 
240     Status ret;
241 
242     int32_t trackId;
243     ret = AddTrack(muxerDemo, trackId);
244     ASSERT_EQ(Status::OK, ret);
245 
246 
247     Destroy(muxerDemo);
248     delete muxerDemo;
249 }
250 /**
251  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_007
252  * @tc.name      : Create -> AddTrack -> AddTrack
253  * @tc.desc      : interface depend check
254  */
255 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_007, TestSize.Level2)
256 {
257     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
258     Create(muxerDemo);
259 
260     Status ret;
261 
262     int32_t trackId;
263     ret = AddTrack(muxerDemo, trackId);
264     ASSERT_EQ(Status::OK, ret);
265 
266     ret = AddTrack(muxerDemo, trackId);
267     ASSERT_EQ(Status::OK, ret);
268 
269 
270     Destroy(muxerDemo);
271     delete muxerDemo;
272 }
273 
274 
275 /**
276  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_008
277  * @tc.name      : Create -> SetRotation -> AddTrack
278  * @tc.desc      : interface depend check
279  */
280 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_008, TestSize.Level2)
281 {
282     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
283     Create(muxerDemo);
284 
285     Status ret;
286 
287     ret = SetRotation(muxerDemo);
288     ASSERT_EQ(Status::OK, ret);
289 
290     int32_t trackId;
291     ret = AddTrack(muxerDemo, trackId);
292     ASSERT_EQ(Status::OK, ret);
293     ASSERT_EQ(0, trackId);
294 
295     Destroy(muxerDemo);
296     delete muxerDemo;
297 }
298 
299 
300 /**
301  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_009
302  * @tc.name      : Create -> AddTrack -> Start -> AddTrack
303  * @tc.desc      : interface depend check
304  */
305 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_009, TestSize.Level2)
306 {
307     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
308     Create(muxerDemo);
309     Status ret;
310 
311     int32_t trackId;
312     ret = AddTrack(muxerDemo, trackId);
313     ASSERT_EQ(Status::OK, ret);
314     ASSERT_EQ(0, trackId);
315 
316     ret = Start(muxerDemo);
317     ASSERT_EQ(Status::OK, ret);
318 
319     ret = AddTrack(muxerDemo, trackId);
320     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
321 
322     Destroy(muxerDemo);
323     delete muxerDemo;
324 }
325 
326 
327 /**
328  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_010
329  * @tc.name      : Create -> AddTrack -> Start -> Stop -> AddTrack
330  * @tc.desc      : interface depend check
331  */
332 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_010, TestSize.Level2)
333 {
334     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
335     Create(muxerDemo);
336 
337     Status ret;
338 
339     int32_t trackId;
340     ret = AddTrack(muxerDemo, trackId);
341     ASSERT_EQ(Status::OK, ret);
342     ASSERT_EQ(0, trackId);
343 
344     ret = Start(muxerDemo);
345     ASSERT_EQ(Status::OK, ret);
346 
347     ret = Stop(muxerDemo);
348     ASSERT_EQ(Status::OK, ret);
349 
350     ret = AddTrack(muxerDemo, trackId);
351     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
352 
353     Destroy(muxerDemo);
354     delete muxerDemo;
355 }
356 
357 
358 /**
359  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_011
360  * @tc.name      : Create -> Start
361  * @tc.desc      : interface depend check
362  */
363 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_011, TestSize.Level2)
364 {
365     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
366     Create(muxerDemo);
367 
368     Status ret;
369 
370     ret = Start(muxerDemo);
371     ASSERT_EQ(Status::ERROR_UNKNOWN, ret);
372 
373     Destroy(muxerDemo);
374     delete muxerDemo;
375 }
376 
377 /**
378  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_012
379  * @tc.name      : Create -> AddTrack -> Start
380  * @tc.desc      : interface depend check
381  */
382 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_012, TestSize.Level2)
383 {
384     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
385     Create(muxerDemo);
386 
387     Status ret;
388 
389     int32_t trackId;
390     ret = AddTrack(muxerDemo, trackId);
391     ASSERT_EQ(Status::OK, ret);
392     ASSERT_EQ(0, trackId);
393 
394     ret = Start(muxerDemo);
395     ASSERT_EQ(Status::OK, ret);
396 
397     Destroy(muxerDemo);
398     delete muxerDemo;
399 }
400 
401 /**
402  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_013
403  * @tc.name      : Create -> SetRotation -> AddTrack -> Start
404  * @tc.desc      : interface depend check
405  */
406 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_013, TestSize.Level2)
407 {
408     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
409     Create(muxerDemo);
410 
411     Status ret;
412 
413     ret = SetRotation(muxerDemo);
414     ASSERT_EQ(Status::OK, ret);
415 
416     int32_t trackId;
417     ret = AddTrack(muxerDemo, trackId);
418     ASSERT_EQ(Status::OK, ret);
419     ASSERT_EQ(0, trackId);
420 
421     ret = Start(muxerDemo);
422     ASSERT_EQ(Status::OK, ret);
423 
424     Destroy(muxerDemo);
425     delete muxerDemo;
426 }
427 
428 /**
429  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_014
430  * @tc.name      : Create -> AddTrack -> Start -> Start
431  * @tc.desc      : interface depend check
432  */
433 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_014, TestSize.Level2)
434 {
435     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
436     Create(muxerDemo);
437 
438     Status ret;
439 
440     int32_t trackId;
441     ret = AddTrack(muxerDemo, trackId);
442     ASSERT_EQ(Status::OK, ret);
443     ASSERT_EQ(0, trackId);
444 
445     ret = Start(muxerDemo);
446     ASSERT_EQ(Status::OK, ret);
447 
448     ret = Start(muxerDemo);
449     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
450 
451     Destroy(muxerDemo);
452     delete muxerDemo;
453 }
454 
455 
456 /**
457  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_015
458  * @tc.name      : Create -> AddTrack -> Start -> Stop -> Start
459  * @tc.desc      : interface depend check
460  */
461 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_015, TestSize.Level2)
462 {
463     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
464     Create(muxerDemo);
465 
466     Status ret;
467 
468     int32_t trackId;
469     ret = AddTrack(muxerDemo, trackId);
470     ASSERT_EQ(Status::OK, ret);
471     ASSERT_EQ(0, trackId);
472 
473     ret = Start(muxerDemo);
474     ASSERT_EQ(Status::OK, ret);
475 
476     ret = Stop(muxerDemo);
477     ASSERT_EQ(Status::OK, ret);
478 
479     ret = Start(muxerDemo);
480     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
481 
482     Destroy(muxerDemo);
483     delete muxerDemo;
484 }
485 
486 
487 /**
488  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_016
489  * @tc.name      : Create -> WriteSampleBuffer
490  * @tc.desc      : interface depend check
491  */
492 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_016, TestSize.Level2)
493 {
494     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
495     Create(muxerDemo);
496 
497     Status ret;
498     int32_t trackId = -1;
499 
500     ret = WriteSampleBuffer(muxerDemo, trackId);
501     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
502 
503     Destroy(muxerDemo);
504     delete muxerDemo;
505 }
506 
507 
508 /**
509  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_017
510  * @tc.name      : Create -> AddTrack -> WriteSampleBuffer
511  * @tc.desc      : interface depend check
512  */
513 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_017, TestSize.Level2)
514 {
515     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
516     Create(muxerDemo);
517 
518     Status ret;
519     int32_t trackId = -1;
520     ret = AddTrack(muxerDemo, trackId);
521     ASSERT_EQ(Status::OK, ret);
522     ASSERT_EQ(0, trackId);
523 
524     ret = WriteSampleBuffer(muxerDemo, trackId);
525     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
526 
527     Destroy(muxerDemo);
528     delete muxerDemo;
529 }
530 
531 
532 /**
533  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_018
534  * @tc.name      : Create -> SetRotation -> AddTrack -> Start -> WriteSampleBuffer
535  * @tc.desc      : interface depend check
536  */
537 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_018, TestSize.Level2)
538 {
539     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
540     Create(muxerDemo);
541 
542     Status ret;
543     int32_t trackId = -1;
544 
545     ret = SetRotation(muxerDemo);
546     ASSERT_EQ(Status::OK, ret);
547     ret = AddTrack(muxerDemo, trackId);
548     ASSERT_EQ(Status::OK, ret);
549     ASSERT_EQ(0, trackId);
550 
551     ret = Start(muxerDemo);
552     ASSERT_EQ(Status::OK, ret);
553 
554     ret = WriteSampleBuffer(muxerDemo, trackId);
555     ASSERT_EQ(Status::OK, ret);
556 
557     Destroy(muxerDemo);
558     delete muxerDemo;
559 }
560 
561 
562 /**
563  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_019
564  * @tc.name      : Create -> AddTrack -> Start -> WriteSampleBuffer
565  * @tc.desc      : interface depend check
566  */
567 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_019, TestSize.Level2)
568 {
569     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
570     Create(muxerDemo);
571 
572     Status ret;
573     int32_t trackId = -1;
574 
575 
576     ret = AddTrack(muxerDemo, trackId);
577     ASSERT_EQ(Status::OK, ret);
578     ASSERT_EQ(0, trackId);
579 
580     ret = Start(muxerDemo);
581     ASSERT_EQ(Status::OK, ret);
582 
583     ret = WriteSampleBuffer(muxerDemo, trackId);
584     ASSERT_EQ(Status::OK, ret);
585 
586     Destroy(muxerDemo);
587     delete muxerDemo;
588 }
589 
590 /**
591  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_020
592  * @tc.name      : Create -> AddTrack -> Start -> WriteSampleBuffer -> WriteSampleBuffer
593  * @tc.desc      : interface depend check
594  */
595 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_020, TestSize.Level2)
596 {
597     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
598     Create(muxerDemo);
599 
600     Status ret;
601     int32_t trackId = -1;
602 
603     ret = AddTrack(muxerDemo, trackId);
604     ASSERT_EQ(Status::OK, ret);
605     ASSERT_EQ(0, trackId);
606 
607     ret = Start(muxerDemo);
608     ASSERT_EQ(Status::OK, ret);
609 
610     ret = WriteSampleBuffer(muxerDemo, trackId);
611     ASSERT_EQ(Status::OK, ret);
612 
613     ret = WriteSampleBuffer(muxerDemo, trackId);
614     ASSERT_EQ(Status::OK, ret);
615 
616     Destroy(muxerDemo);
617     delete muxerDemo;
618 }
619 
620 
621 /**
622  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_021
623  * @tc.name      : Create -> AddTrack -> Start -> Stop -> WriteSampleBuffer
624  * @tc.desc      : interface depend check
625  */
626 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_021, TestSize.Level2)
627 {
628     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
629     Create(muxerDemo);
630 
631     Status ret;
632     int32_t trackId = -1;
633     ret = AddTrack(muxerDemo, trackId);
634     ASSERT_EQ(Status::OK, ret);
635     ASSERT_EQ(0, trackId);
636 
637     ret = Start(muxerDemo);
638     ASSERT_EQ(Status::OK, ret);
639 
640     ret = Stop(muxerDemo);
641     ASSERT_EQ(Status::OK, ret);
642 
643     ret = WriteSampleBuffer(muxerDemo, trackId);
644     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
645 
646     Destroy(muxerDemo);
647     delete muxerDemo;
648 }
649 
650 
651 /**
652  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_022
653  * @tc.name      : Create -> Stop
654  * @tc.desc      : interface depend check
655  */
656 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_022, TestSize.Level2)
657 {
658     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
659     Create(muxerDemo);
660 
661 
662     Status ret;
663 
664     ret = Stop(muxerDemo);
665     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
666 
667     Destroy(muxerDemo);
668     delete muxerDemo;
669 }
670 
671 
672 /**
673  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_023
674  * @tc.name      : Create -> AddTrack -> Stop
675  * @tc.desc      : interface depend check
676  */
677 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_023, TestSize.Level2)
678 {
679     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
680     Create(muxerDemo);
681 
682     Status ret;
683 
684     int32_t trackId;
685     ret = AddTrack(muxerDemo, trackId);
686     ASSERT_EQ(Status::OK, ret);
687     ASSERT_EQ(0, trackId);
688 
689     ret = Stop(muxerDemo);
690     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
691 
692     Destroy(muxerDemo);
693     delete muxerDemo;
694 }
695 
696 
697 /**
698  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_024
699  * @tc.name      : Create -> AddTrack -> Start -> Stop
700  * @tc.desc      : interface depend check
701  */
702 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_024, TestSize.Level2)
703 {
704     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
705     Create(muxerDemo);
706 
707 
708     Status ret;
709 
710     int32_t trackId;
711     ret = AddTrack(muxerDemo, trackId);
712     ASSERT_EQ(Status::OK, ret);
713     ASSERT_EQ(0, trackId);
714 
715     ret = Start(muxerDemo);
716     ASSERT_EQ(Status::OK, ret);
717 
718     ret = Stop(muxerDemo);
719     ASSERT_EQ(Status::OK, ret);
720 
721     Destroy(muxerDemo);
722     delete muxerDemo;
723 }
724 
725 
726 /**
727  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_025
728  * @tc.name      : Create -> SetRotation -> AddTrack -> Start -> Stop
729  * @tc.desc      : interface depend check
730  */
731 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_025, TestSize.Level2)
732 {
733     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
734     Create(muxerDemo);
735 
736     Status ret;
737 
738     ret = SetRotation(muxerDemo);
739     ASSERT_EQ(Status::OK, ret);
740 
741     int32_t trackId;
742     ret = AddTrack(muxerDemo, trackId);
743     ASSERT_EQ(Status::OK, ret);
744     ASSERT_EQ(0, trackId);
745 
746     ret = Start(muxerDemo);
747     ASSERT_EQ(Status::OK, ret);
748 
749     ret = Stop(muxerDemo);
750     ASSERT_EQ(Status::OK, ret);
751 
752     Destroy(muxerDemo);
753     delete muxerDemo;
754 }
755 
756 
757 /**
758  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_026
759  * @tc.name      : Create -> AddTrack -> Start -> WriteSampleBuffer -> Stop -> Stop
760  * @tc.desc      : interface depend check
761  */
762 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_026, TestSize.Level2)
763 {
764     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
765     Create(muxerDemo);
766 
767     Status ret;
768 
769     int32_t trackId;
770     ret = AddTrack(muxerDemo, trackId);
771     ASSERT_EQ(Status::OK, ret);
772     ASSERT_EQ(0, trackId);
773 
774     ret = Start(muxerDemo);
775     ASSERT_EQ(Status::OK, ret);
776 
777     ret = WriteSampleBuffer(muxerDemo, trackId);
778     ASSERT_EQ(Status::OK, ret);
779 
780     ret = Stop(muxerDemo);
781     ASSERT_EQ(Status::OK, ret);
782 
783     ret = Stop(muxerDemo);
784     ASSERT_EQ(Status::ERROR_WRONG_STATE, ret);
785 
786     Destroy(muxerDemo);
787     delete muxerDemo;
788 }
789 
790 
791 /**
792  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_027
793  * @tc.name      : Create -> Destroy
794  * @tc.desc      : interface depend check
795  */
796 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_027, TestSize.Level2)
797 {
798     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
799     Create(muxerDemo);
800 
801     Status ret;
802 
803     ret = Destroy(muxerDemo);
804     ASSERT_EQ(Status::OK, ret);
805 
806     delete muxerDemo;
807 }
808 
809 
810 /**
811  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_028
812  * @tc.name      : Create -> SetRotation -> Destroy
813  * @tc.desc      : interface depend check
814  */
815 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_028, TestSize.Level2)
816 {
817     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
818     Create(muxerDemo);
819 
820 
821     Status ret;
822 
823     ret = SetRotation(muxerDemo);
824     ASSERT_EQ(Status::OK, ret);
825 
826     ret = Destroy(muxerDemo);
827     ASSERT_EQ(Status::OK, ret);
828 
829     delete muxerDemo;
830 }
831 
832 
833 /**
834  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_029
835  * @tc.name      : Create -> AddTrack -> Destroy
836  * @tc.desc      : interface depend check
837  */
838 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_029, TestSize.Level2)
839 {
840     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
841     Create(muxerDemo);
842 
843     Status ret;
844 
845     int32_t trackId;
846     ret = AddTrack(muxerDemo, trackId);
847     ASSERT_EQ(Status::OK, ret);
848     ASSERT_EQ(0, trackId);
849 
850     ret = Destroy(muxerDemo);
851     ASSERT_EQ(Status::OK, ret);
852 
853     delete muxerDemo;
854 }
855 
856 
857 /**
858  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_030
859  * @tc.name      : Create -> AddTrack -> Start -> Destroy
860  * @tc.desc      : interface depend check
861  */
862 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_030, TestSize.Level2)
863 {
864     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
865     Create(muxerDemo);
866 
867     Status ret;
868 
869     int32_t trackId;
870     ret = AddTrack(muxerDemo, trackId);
871     ASSERT_EQ(Status::OK, ret);
872     ASSERT_EQ(0, trackId);
873 
874     ret = Start(muxerDemo);
875     ASSERT_EQ(Status::OK, ret);
876 
877     ret = Destroy(muxerDemo);
878     ASSERT_EQ(Status::OK, ret);
879 
880     delete muxerDemo;
881 }
882 
883 
884 /**
885  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_031
886  * @tc.name      : Create -> AddTrack -> Start -> WriteSampleBuffer -> Destroy
887  * @tc.desc      : interface depend check
888  */
889 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_031, TestSize.Level2)
890 {
891     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
892     Create(muxerDemo);
893 
894     Status ret;
895 
896     int32_t trackId;
897     ret = AddTrack(muxerDemo, trackId);
898     ASSERT_EQ(Status::OK, ret);
899     ASSERT_EQ(0, trackId);
900 
901     ret = Start(muxerDemo);
902     ASSERT_EQ(Status::OK, ret);
903 
904     ret = WriteSampleBuffer(muxerDemo, trackId);
905     ASSERT_EQ(Status::OK, ret);
906 
907     ret = Destroy(muxerDemo);
908     ASSERT_EQ(Status::OK, ret);
909 
910     delete muxerDemo;
911 }
912 
913 
914 /**
915  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_032
916  * @tc.name      : Create -> AddTrack -> Start -> WriteSampleBuffer -> Stop -> Destroy
917  * @tc.desc      : interface depend check
918  */
919 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_032, TestSize.Level2)
920 {
921     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
922     Create(muxerDemo);
923 
924     Status ret;
925 
926     int32_t trackId;
927     ret = AddTrack(muxerDemo, trackId);
928     ASSERT_EQ(Status::OK, ret);
929     ASSERT_EQ(0, trackId);
930 
931     ret = Start(muxerDemo);
932     ASSERT_EQ(Status::OK, ret);
933 
934     ret = WriteSampleBuffer(muxerDemo, trackId);
935     ASSERT_EQ(Status::OK, ret);
936 
937     ret = Stop(muxerDemo);
938     ASSERT_EQ(Status::OK, ret);
939 
940     ret = Destroy(muxerDemo);
941     ASSERT_EQ(Status::OK, ret);
942 
943     delete muxerDemo;
944 }
945 
946 
947 /**
948  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_033
949  * @tc.name      : Create -> SetRotation ->  AddTrack -> Start -> WriteSampleBuffer -> Stop -> Destroy
950  * @tc.desc      : interface depend check
951  */
952 HWTEST_F(FFmpegAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_033, TestSize.Level2)
953 {
954     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
955     Create(muxerDemo);
956 
957     Status ret;
958 
959     ret = SetRotation(muxerDemo);
960     ASSERT_EQ(Status::OK, ret);
961 
962     int32_t trackId;
963     ret = AddTrack(muxerDemo, trackId);
964     ASSERT_EQ(Status::OK, ret);
965     ASSERT_EQ(0, trackId);
966 
967     ret = Start(muxerDemo);
968     ASSERT_EQ(Status::OK, ret);
969 
970     ret = WriteSampleBuffer(muxerDemo, trackId);
971     ASSERT_EQ(Status::OK, ret);
972 
973     ret = Stop(muxerDemo);
974     ASSERT_EQ(Status::OK, ret);
975 
976     ret = Destroy(muxerDemo);
977     ASSERT_EQ(Status::OK, ret);
978 
979     delete muxerDemo;
980 }