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