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
21using namespace std;
22using namespace testing::ext;
23using namespace OHOS;
24using namespace OHOS::MediaAVCodec;
25using namespace OHOS::Media;
26
27namespace {
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
36    void InnerAVMuxerParamCheckTest::SetUpTestCase() {}
37    void InnerAVMuxerParamCheckTest::TearDownTestCase() {}
38    void InnerAVMuxerParamCheckTest::SetUp() {}
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 */
49HWTEST_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 */
71HWTEST_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 */
101HWTEST_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 */
147HWTEST_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 */
194HWTEST_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 */
230HWTEST_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 */
265HWTEST_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 */
313HWTEST_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 */
349HWTEST_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 */
385HWTEST_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 */
412HWTEST_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 */
458HWTEST_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 */
502HWTEST_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 */
545HWTEST_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 */
590HWTEST_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 */
631HWTEST_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