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 <iostream>
18 #include <thread>
19 #include <vector>
20 #include "gtest/gtest.h"
21 #include "AVMuxerDemo.h"
22 #include "fcntl.h"
23 #include "avcodec_info.h"
24 #include "securec.h"
25 #include "avcodec_errors.h"
26
27 using namespace std;
28 using namespace testing::ext;
29 using namespace OHOS;
30 using namespace OHOS::MediaAVCodec;
31 constexpr uint32_t SAMPLE_RATE = 44100;
32 constexpr uint32_t CHANNEL_COUNT = 2;
33
34 namespace {
35 class FFmpegAVMuxerFunctionTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp() override;
40 void TearDown() override;
41 };
42
SetUpTestCase()43 void FFmpegAVMuxerFunctionTest::SetUpTestCase() {}
TearDownTestCase()44 void FFmpegAVMuxerFunctionTest::TearDownTestCase() {}
SetUp()45 void FFmpegAVMuxerFunctionTest::SetUp() {}
TearDown()46 void FFmpegAVMuxerFunctionTest::TearDown() {}
47
48 static int g_inputFile = -1;
49 static const int DATA_AUDIO_ID = 0;
50 static const int DATA_VIDEO_ID = 1;
51 constexpr int32_t BIG_EXTRA_SIZE = 100;
52 constexpr int32_t WIDTH = 352;
53 constexpr int32_t HEIGHT = 288;
54
55 Plugin::Status g_testResult[10] = { Plugin::Status::ERROR_UNKNOWN };
56
AddAudioTrack(AVMuxerDemo * muxerDemo,int32_t & trackIndex)57 Plugin::Status AddAudioTrack(AVMuxerDemo *muxerDemo, int32_t &trackIndex)
58 {
59 MediaDescription audioParams;
60
61 int extraSize = 0;
62 unsigned char buffer[100] = {0};
63 read(g_inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
64 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
65 read(g_inputFile, buffer, extraSize);
66 audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, static_cast<uint8_t*>buffer, extraSize);
67 }
68 audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_MPEG);
69 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
70 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
71
72 Plugin::Status ret = muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
73
74 return ret;
75 }
76
AddVideoTrack(AVMuxerDemo * muxerDemo,int32_t & trackIndex)77 Plugin::Status AddVideoTrack(AVMuxerDemo *muxerDemo, int32_t &trackIndex)
78 {
79 MediaDescription videoParams;
80
81 int extraSize = 0;
82 unsigned char buffer[100] = {0};
83
84 read(g_inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
85 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
86 read(g_inputFile, buffer, extraSize);
87 videoParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, static_cast<uint8_t*>buffer, extraSize);
88 }
89
90 videoParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_MPEG4);
91 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, WIDTH);
92 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, HEIGHT);
93
94 Plugin::Status ret = muxerDemo->FFmpegAddTrack(trackIndex, videoParams);
95
96 return ret;
97 }
98
AddVideoTrackH264ByFd(AVMuxerDemo * muxerDemo,int32_t inputFile,int32_t & trackIndex)99 Plugin::Status AddVideoTrackH264ByFd(AVMuxerDemo *muxerDemo, int32_t inputFile, int32_t &trackIndex)
100 {
101 MediaDescription videoParams;
102
103 int extraSize = 0;
104 unsigned char buffer[100] = {0};
105
106 read(inputFile, static_cast<void*>&extraSize, sizeof(extraSize));
107 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
108 read(g_inputFile, buffer, extraSize);
109 videoParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, static_cast<uint8_t*>buffer, extraSize);
110 }
111
112 videoParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_AVC);
113 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, WIDTH);
114 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, HEIGHT);
115
116 Plugin::Status ret = muxerDemo->FFmpegAddTrack(trackIndex, videoParams);
117
118 return ret;
119 }
AddCoverTrack(AVMuxerDemo * muxerDemo,string coverType,int32_t trackIndex)120 Plugin::Status AddCoverTrack(AVMuxerDemo *muxerDemo, string coverType, int32_t trackIndex)
121 {
122 MediaDescription coverParams;
123
124 if (coverType == "jpg") {
125 coverParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::IMAGE_JPG);
126 } else if (coverType == "png") {
127 coverParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::IMAGE_PNG);
128 } else {
129 coverParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::IMAGE_BMP);
130 }
131
132 coverParams.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, WIDTH);
133 coverParams.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, HEIGHT);
134
135 Plugin::Status ret = muxerDemo->FFmpegAddTrack(trackIndex, coverParams);
136
137 return ret;
138 }
139
RemoveHeader()140 void RemoveHeader()
141 {
142 int extraSize = 0;
143 unsigned char buffer[100] = {0};
144 read(g_inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
145 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
146 read(g_inputFile, buffer, extraSize);
147 }
148 }
149
WriteTrackSample(AVMuxerDemo * muxerDemo,int audioTrackIndex,int videoTrackIndex)150 void WriteTrackSample(AVMuxerDemo *muxerDemo, int audioTrackIndex, int videoTrackIndex)
151 {
152 int dataTrackId = 0;
153 int dataSize = 0;
154 int ret = 0;
155 int trackId = 0;
156 AVCodecBufferInfo info;
157 uint32_t trackIndex;
158 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
159 uint8_t data[1024 * 1024] = {0};
160 while (1) {
161 ret = read(g_inputFile, static_cast<void*>(&dataTrackId), sizeof(dataTrackId));
162 if (ret <= 0) {
163 cout << "read dataTrackId error, ret is: " << (int)ret << endl;
164 return;
165 }
166 ret = read(g_inputFile, static_cast<void*>(&info.presentationTimeUs), sizeof(info.presentationTimeUs));
167 if (ret <= 0) {
168 cout << "read nfo.presentationTimeUs error, ret is: " << (int)ret << endl;
169 return;
170 }
171 ret = read(g_inputFile, static_cast<void*>(&dataSize), sizeof(dataSize));
172 if (ret <= 0) {
173 cout << "read nfo.size error, ret is: " << (int)ret << endl;
174 return;
175 }
176 ret = read(g_inputFile, static_cast<void*>data, dataSize);
177 if (ret <= 0) {
178 cout << "read info.flags error, ret is: " << (int)ret << endl;
179 return;
180 }
181 info.size = dataSize;
182 if (dataTrackId == DATA_AUDIO_ID) {
183 trackIndex = audioTrackIndex;
184 } else if (dataTrackId == DATA_VIDEO_ID) {
185 trackIndex = videoTrackIndex;
186 } else {
187 cout << "error trackIndex : " << trackId << endl;
188 }
189 if (dataTrackId >= 0) {
190 Plugin::Status result = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
191 if (result != Plugin::Status::NO_ERROR) {
192 return;
193 }
194 }
195 }
196 }
197
WriteTrackSampleShort(AVMuxerDemo * muxerDemo,int audioTrackIndex,int videoTrackIndex,int audioWriteTime)198 void WriteTrackSampleShort(AVMuxerDemo *muxerDemo, int audioTrackIndex, int videoTrackIndex, int audioWriteTime)
199 {
200 int dataTrackId = 0;
201 int dataSize = 0;
202 int ret = 0;
203 int trackId = 0;
204 int curTime = 0;
205 AVCodecBufferInfo info;
206 uint32_t trackIndex;
207 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
208 uint8_t data[1024 * 1024] = {0};
209 while (1) {
210 ret = read(g_inputFile, static_cast<void*>(&dataTrackId), sizeof(dataTrackId));
211 if (ret <= 0) {
212 return;
213 }
214 ret = read(g_inputFile, static_cast<void*>(&info.presentationTimeUs), sizeof(info.presentationTimeUs));
215 if (ret <= 0) {
216 return;
217 }
218 ret = read(g_inputFile, static_cast<void*>(&dataSize), sizeof(dataSize));
219 if (ret <= 0) {
220 return;
221 }
222 ret = read(g_inputFile, static_cast<void*>data, dataSize);
223 if (ret <= 0) {
224 return;
225 }
226
227 info.size = dataSize;
228 if (dataTrackId == DATA_AUDIO_ID) {
229 trackIndex = audioTrackIndex;
230 } else if (dataTrackId == DATA_VIDEO_ID) {
231 trackIndex = videoTrackIndex;
232 } else {
233 printf("error dataTrackId : %d", trackId);
234 }
235 if (trackId >= 0) {
236 if (trackId == audioTrackIndex && curTime > audioWriteTime) {
237 continue;
238 } else if (trackId == audioTrackIndex) {
239 curTime++;
240 }
241 Plugin::Status result = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
242 if (result != Plugin::Status::NO_ERROR) {
243 printf("OH_AVMuxer_WriteSampleBuffer error!");
244 return;
245 }
246 }
247 }
248 }
249
AddAudioTrackByFd(AVMuxerDemo * muxerDemo,int32_t inputFile,int32_t & trackIndex)250 Plugin::Status AddAudioTrackByFd(AVMuxerDemo *muxerDemo, int32_t inputFile, int32_t &trackIndex)
251 {
252 MediaDescription audioParams;
253
254 int extraSize = 0;
255 unsigned char buffer[100] = {0};
256
257 read(inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
258 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
259 read(inputFile, buffer, extraSize);
260 audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, static_cast<uint8_t*>buffer, extraSize);
261 }
262
263 audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_MPEG);
264 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
265 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
266 Plugin::Status ret = muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
267
268 return ret;
269 }
270
AddAudioTrackAACByFd(AVMuxerDemo * muxerDemo,int32_t inputFile,int32_t & trackIndex)271 Plugin::Status AddAudioTrackAACByFd(AVMuxerDemo *muxerDemo, int32_t inputFile, int32_t &trackIndex)
272 {
273 MediaDescription audioParams;
274
275 int extraSize = 0;
276 unsigned char buffer[100] = {0};
277
278 read(inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
279 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
280 read(inputFile, buffer, extraSize);
281 audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, static_cast<uint8_t*>buffer, extraSize);
282 }
283 audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
284 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
285 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
286
287 Plugin::Status ret = muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
288
289 return ret;
290 }
291
AddVideoTrackByFd(AVMuxerDemo * muxerDemo,int32_t inputFile,int32_t & trackIndex)292 Plugin::Status AddVideoTrackByFd(AVMuxerDemo *muxerDemo, int32_t inputFile, int32_t &trackIndex)
293 {
294 MediaDescription videoParams;
295
296 int extraSize = 0;
297 unsigned char buffer[100] = {0};
298
299 read(inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
300 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
301 read(inputFile, buffer, extraSize);
302 videoParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, static_cast<uint8_t*>buffer, extraSize);
303 }
304
305 videoParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_MPEG4);
306 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, WIDTH);
307 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, HEIGHT);
308
309 Plugin::Status ret = muxerDemo->FFmpegAddTrack(trackIndex, videoParams);
310
311 return ret;
312 }
313
WriteTrackSampleByFdRead(int * inputFile,AVCodecBufferInfo * info,int * dataSize,int * dataTrackId)314 int WriteTrackSampleByFdRead(int *inputFile, AVCodecBufferInfo *info, int *dataSize, int *dataTrackId)
315 {
316 int ret = read(*inputFile, static_cast<void*>dataTrackId, sizeof(*dataTrackId));
317 if (ret <= 0) {
318 cout << "read dataTrackId error, ret is: " << ret << endl;
319 return -1;
320 }
321 ret = read(*inputFile, static_cast<void*>(&info->presentationTimeUs), sizeof(info->presentationTimeUs));
322 if (ret <= 0) {
323 cout << "read info.pts error, ret is: " << ret << endl;
324 return -1;
325 }
326 ret = read(*inputFile, static_cast<void*>dataSize, sizeof(*dataSize));
327 if (ret <= 0) {
328 cout << "read dataSize error, ret is: " << ret << endl;
329 return -1;
330 }
331 return 0;
332 }
333
WriteTrackSampleByFdMem(int * dataSize,unsigned char * avMuxerDemoBuffer,int * avMuxerDemoBufferSize)334 int WriteTrackSampleByFdMem(int *dataSize, unsigned char *avMuxerDemoBuffer, int *avMuxerDemoBufferSize)
335 {
336 if (avMuxerDemoBuffer != nullptr && *dataSize > *avMuxerDemoBufferSize) {
337 free(avMuxerDemoBuffer);
338 *avMuxerDemoBufferSize = 0;
339 avMuxerDemoBuffer = nullptr;
340 }
341 if (avMuxerDemoBuffer == nullptr) {
342 avMuxerDemoBuffer = static_cast<unsigned char*>malloc(*dataSize);
343 *avMuxerDemoBufferSize = *dataSize;
344 if (avMuxerDemoBuffer == nullptr) {
345 printf("error malloc memory!\n");
346 return -1;
347 }
348 }
349 return 0;
350 }
351
WriteTrackSampleByFd(AVMuxerDemo * muxerDemo,int audioTrackIndex,int videoTrackIndex,int32_t inputFile)352 void WriteTrackSampleByFd(AVMuxerDemo *muxerDemo, int audioTrackIndex, int videoTrackIndex, int32_t inputFile)
353 {
354 int dataTrackId = 0;
355 int dataSize = 0;
356 int ret = 0;
357 int trackId = 0;
358 AVCodecBufferInfo info;
359 uint32_t trackIndex;
360 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
361 unsigned char *avMuxerDemoBuffer = nullptr;
362 int avMuxerDemoBufferSize = 0;
363 string resultStr = "";
364 while (1) {
365 ret = WriteTrackSampleByFdRead(&inputFile, &info, &dataSize, &dataTrackId);
366 if (ret != 0) {
367 return;
368 }
369
370 ret = WriteTrackSampleByFdMem(&dataSize, avMuxerDemoBuffer, &avMuxerDemoBufferSize);
371 if (ret != 0) {
372 break;
373 }
374
375 resultStr =
376 "inputFile is: " + to_string(inputFile) + ", avMuxerDemoBufferSize is " + to_string(avMuxerDemoBufferSize);
377 cout << resultStr << endl;
378
379 ret = read(inputFile, static_cast<void*>avMuxerDemoBuffer, dataSize);
380 if (ret <= 0) {
381 cout << "read data error, ret is: " << (int)ret << endl;
382 continue;
383 }
384
385 info.size = dataSize;
386 if (dataTrackId == DATA_AUDIO_ID) {
387 trackIndex = audioTrackIndex;
388 } else if (dataTrackId == DATA_VIDEO_ID) {
389 trackIndex = videoTrackIndex;
390 } else {
391 cout << "error dataTrackId : " << trackId << endl;
392 }
393 if (trackId >= 0) {
394 Plugin::Status result = muxerDemo->FFmpegWriteSample(trackIndex, avMuxerDemoBuffer, info, flag);
395 if (result != Plugin::Status::NO_ERROR) {
396 cout << "OH_AVMuxer_WriteSampleBuffer error! ret is: " << (int)result << endl;
397 break;
398 }
399 }
400 }
401 if (avMuxerDemoBuffer != nullptr) {
402 free(avMuxerDemoBuffer);
403 }
404 }
WriteTrackCover(AVMuxerDemo * muxerDemo,int coverTrackIndex,int32_t fdInput)405 void WriteTrackCover(AVMuxerDemo *muxerDemo, int coverTrackIndex, int32_t fdInput)
406 {
407 printf("WriteTrackCover\n");
408 AVCodecBufferInfo info;
409 uint32_t trackIndex;
410 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
411 memset_s(&info, sizeof(info), 0, sizeof(info));
412 struct stat fileStat;
413 fstat(fdInput, &fileStat);
414 info.size = fileStat.st_size;
415 unsigned char *avMuxerDemoBuffer = static_cast<unsigned char*>malloc(info.size);
416 if (avMuxerDemoBuffer == nullptr) {
417 printf("malloc memory error! size: %d \n", info.size);
418 return;
419 }
420
421 int ret = read(fdInput, avMuxerDemoBuffer, info.size);
422 if (ret <= 0) {
423 free(avMuxerDemoBuffer);
424 return;
425 }
426 trackIndex = coverTrackIndex;
427 Plugin::Status result = muxerDemo->FFmpegWriteSample(trackIndex, avMuxerDemoBuffer, info, flag);
428 if (result != Plugin::Status::NO_ERROR) {
429 free(avMuxerDemoBuffer);
430 cout << "WriteTrackCover error! " << endl;
431 return;
432 }
433 free(avMuxerDemoBuffer);
434 }
435
WriteSingleTrackSampleRead(int * fd,AVCodecBufferInfo * info,int * flags,int * dataSize)436 int WriteSingleTrackSampleRead(int *fd, AVCodecBufferInfo *info, int *flags, int *dataSize)
437 {
438 int ret = 0;
439 ret = read(*fd, static_cast<void*>(&info->presentationTimeUs), sizeof(info->presentationTimeUs));
440 if (ret <= 0) {
441 return -1;
442 }
443
444 ret = read(*fd, static_cast<void*>flags, sizeof(*flags));
445 if (ret <= 0) {
446 return -1;
447 }
448
449 // read frame buffer
450 ret = read(*fd, static_cast<void*>dataSize, sizeof(*dataSize));
451 if (ret <= 0 || *dataSize < 0) {
452 return -1;
453 }
454 return 0;
455 }
456
WriteSingleTrackSample(AVMuxerDemo * muxerDemo,int trackId,int fd)457 void WriteSingleTrackSample(AVMuxerDemo *muxerDemo, int trackId, int fd)
458 {
459 int ret = 0;
460 int dataSize = 0;
461 int flags = 0;
462 unsigned char *avMuxerDemoBuffer = nullptr;
463 int avMuxerDemoBufferSize = 0;
464 AVCodecBufferInfo info;
465 uint32_t trackIndex;
466 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
467 memset_s(&info, sizeof(info), 0, sizeof(info));
468 while (1) {
469 ret = WriteSingleTrackSampleRead(&fd, &info, &flags, &dataSize);
470 if (ret != 0) {
471 break;
472 }
473
474 if (avMuxerDemoBuffer != nullptr && dataSize > avMuxerDemoBufferSize) {
475 free(avMuxerDemoBuffer);
476 avMuxerDemoBufferSize = 0;
477 avMuxerDemoBuffer = nullptr;
478 }
479 if (avMuxerDemoBuffer == nullptr) {
480 avMuxerDemoBuffer = static_cast<unsigned char*>malloc(dataSize);
481 avMuxerDemoBufferSize = dataSize;
482 if (avMuxerDemoBuffer == nullptr) {
483 printf("error malloc memory! %d\n", dataSize);
484 break;
485 }
486 }
487 ret = read(fd, static_cast<void*>avMuxerDemoBuffer, dataSize);
488 if (ret <= 0) {
489 break;
490 }
491 info.size = dataSize;
492
493 if (flag != 0) {
494 flag = AVCODEC_BUFFER_FLAG_SYNC_FRAME;
495 }
496 trackIndex = trackId;
497 Plugin::Status result = muxerDemo->FFmpegWriteSample(trackIndex, avMuxerDemoBuffer, info, flag);
498 if (result != Plugin::Status::NO_ERROR) {
499 cout << "WriteSingleTrackSample error! " << endl;
500 break;
501 }
502 }
503
504 if (avMuxerDemoBuffer != nullptr) {
505 free(avMuxerDemoBuffer);
506 }
507 }
508
runMuxer(string testcaseName,int threadId,OutputFormat format)509 void runMuxer(string testcaseName, int threadId, OutputFormat format)
510 {
511 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
512 string fileName = testcaseName + "_" + to_string(threadId);
513
514 cout << "thread id is: " << threadId << ", cur file name is: " << fileName << endl;
515 int32_t fd = muxerDemo->FFmpeggetFdByName(format, fileName);
516
517 int32_t inputFile;
518 int32_t audioTrackId;
519 int32_t videoTrackId;
520
521 cout << "thread id is: " << threadId << ", fd is: " << fd << endl;
522 muxerDemo->FFmpegCreate(fd);
523
524 Plugin::Status ret;
525
526 if (format == OUTPUT_FORMAT_MPEG_4) {
527 cout << "thread id is: " << threadId << ", format is: " << format << endl;
528 inputFile = open("avDataMpegMpeg4.bin", O_RDONLY);
529 AddAudioTrackByFd(muxerDemo, inputFile, audioTrackId);
530 AddVideoTrackByFd(muxerDemo, inputFile, videoTrackId);
531 } else {
532 cout << "thread id is: " << threadId << ", format is: " << format << endl;
533 inputFile = open("avData_mpeg4_aac_2.bin", O_RDONLY);
534 AddAudioTrackAACByFd(muxerDemo, inputFile, audioTrackId);
535 AddVideoTrackByFd(muxerDemo, inputFile, videoTrackId);
536 }
537
538 cout << "thread id is: " << threadId << ", audio track id is: " << audioTrackId
539 << ", video track id is: " << videoTrackId << endl;
540
541 ret = muxerDemo->FFmpegStart();
542 cout << "thread id is: " << threadId << ", Start ret is:" << (int)ret << endl;
543
544 WriteTrackSampleByFd(muxerDemo, audioTrackId, videoTrackId, inputFile);
545
546 ret = muxerDemo->FFmpegStop();
547 cout << "thread id is: " << threadId << ", Stop ret is:" << (int)ret << endl;
548
549 ret = muxerDemo->FFmpegDestroy();
550 cout << "thread id is: " << threadId << ", Destroy ret is:" << (int)ret << endl;
551
552 g_testResult[threadId] = Plugin::Status::OK;
553 close(inputFile);
554 close(fd);
555 delete muxerDemo;
556 }
557 } // namespace
558
559 /**
560 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_001
561 * @tc.name : audio
562 * @tc.desc : Function test
563 */
564 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_001, TestSize.Level2)
565 {
566 OutputFormat formatList[] = {OUTPUT_FORMAT_M4A, OUTPUT_FORMAT_MPEG_4};
567 for (int i = 0; i < 2; i++) {
568 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
569
570 OutputFormat format = formatList[i];
571 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "FUNCTION_001");
572
573 int32_t audioFileFd = open("aac_44100_2.bin", O_RDONLY);
574 muxerDemo->FFmpegCreate(fd);
575
576 int32_t audioTrackId;
577 AddAudioTrackAACByFd(muxerDemo, audioFileFd, audioTrackId);
578
579 int32_t videoTrackId = -1;
580 RemoveHeader();
581
582 cout << "audio track id is: " << audioTrackId << ", video track id is: " << videoTrackId << endl;
583
584 Plugin::Status ret;
585
586 ret = muxerDemo->FFmpegStart();
587 ASSERT_EQ(Plugin::Status::OK, ret);
588
589 if (audioTrackId >= 0) {
590 WriteSingleTrackSample(muxerDemo, audioTrackId, audioFileFd);
591 }
592
593 ret = muxerDemo->FFmpegStop();
594 ASSERT_EQ(Plugin::Status::OK, ret);
595
596 ret = muxerDemo->FFmpegDestroy();
597 ASSERT_EQ(Plugin::Status::OK, ret);
598
599 close(audioFileFd);
600 close(fd);
601 delete muxerDemo;
602 }
603 }
604
605 /**
606 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_002
607 * @tc.name : video
608 * @tc.desc : Function test
609 */
610 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_002, TestSize.Level2)
611 {
612 OutputFormat formatList[] = {OUTPUT_FORMAT_M4A, OUTPUT_FORMAT_MPEG_4};
613 for (int i = 0; i < 2; i++) {
614 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
615
616 OutputFormat format = formatList[i];
617 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "FUNCTION_002");
618
619 int32_t videoFileFd = open("h264_640_360.bin", O_RDONLY);
620
621 muxerDemo->FFmpegCreate(fd);
622
623 int32_t audioTrackId = -1;
624 int32_t videoTrackId;
625 AddVideoTrackByFd(muxerDemo, videoFileFd, videoTrackId);
626
627 cout << "audio track id is: " << audioTrackId << ", video track id is: " << videoTrackId << endl;
628
629 Plugin::Status ret;
630
631 ret = muxerDemo->FFmpegStart();
632 ASSERT_EQ(Plugin::Status::OK, ret);
633
634 if (videoTrackId >= 0) {
635 WriteSingleTrackSample(muxerDemo, videoTrackId, videoFileFd);
636 }
637
638 ret = muxerDemo->FFmpegStop();
639 ASSERT_EQ(Plugin::Status::OK, ret);
640
641 ret = muxerDemo->FFmpegDestroy();
642 ASSERT_EQ(Plugin::Status::OK, ret);
643
644 close(videoFileFd);
645 close(fd);
646 delete muxerDemo;
647 }
648 }
649
650 /**
651 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_003
652 * @tc.name : audio and video
653 * @tc.desc : Function test
654 */
655 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_003, TestSize.Level2)
656 {
657 OutputFormat formatList[] = {OUTPUT_FORMAT_M4A, OUTPUT_FORMAT_MPEG_4};
658 for (int i = 0; i < 2; i++) {
659 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
660
661 OutputFormat format = formatList[i];
662 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "FUNCTION_003");
663
664 int32_t audioFileFd = open("aac_44100_2.bin", O_RDONLY);
665 int32_t videoFileFd = open("mpeg4_720_480.bin", O_RDONLY);
666
667 muxerDemo->FFmpegCreate(fd);
668
669 int32_t audioTrackId;
670 AddAudioTrackAACByFd(muxerDemo, audioFileFd, audioTrackId);
671 int32_t videoTrackId;
672 AddVideoTrackByFd(muxerDemo, videoFileFd, videoTrackId);
673
674 cout << "audio track id is: " << audioTrackId << ", video track id is: " << videoTrackId << endl;
675
676 Plugin::Status ret;
677
678 ret = muxerDemo->FFmpegStart();
679 ASSERT_EQ(Plugin::Status::OK, ret);
680
681 if (audioTrackId >= 0) {
682 WriteSingleTrackSample(muxerDemo, audioTrackId, audioFileFd);
683 }
684 if (videoTrackId >= 0) {
685 WriteSingleTrackSample(muxerDemo, videoTrackId, videoFileFd);
686 }
687
688 ret = muxerDemo->FFmpegStop();
689 ASSERT_EQ(Plugin::Status::OK, ret);
690
691 ret = muxerDemo->FFmpegDestroy();
692 ASSERT_EQ(Plugin::Status::OK, ret);
693
694 close(audioFileFd);
695 close(videoFileFd);
696 close(fd);
697 delete muxerDemo;
698 }
699 }
700
701 /**
702 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_004
703 * @tc.name : mp4(SetRotation)
704 * @tc.desc : Function test
705 */
706 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_004, TestSize.Level2)
707 {
708 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
709
710 OutputFormat format = OUTPUT_FORMAT_MPEG_4;
711 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "FUNCTION_004");
712
713 g_inputFile = open("avDataMpegMpeg4.bin", O_RDONLY);
714
715 muxerDemo->FFmpegCreate(fd);
716
717 int32_t audioTrackId;
718 AddAudioTrack(muxerDemo, audioTrackId);
719 int32_t videoTrackId;
720 AddVideoTrack(muxerDemo, videoTrackId);
721
722 cout << "audio track id is: " << audioTrackId << ", video track id is: " << videoTrackId << endl;
723
724 Plugin::Status ret;
725 ret = muxerDemo->FFmpegSetRotation(90);
726 ASSERT_EQ(Plugin::Status::OK, ret);
727
728 ret = muxerDemo->FFmpegStart();
729 ASSERT_EQ(Plugin::Status::OK, ret);
730
731 WriteTrackSample(muxerDemo, audioTrackId, videoTrackId);
732
733 ret = muxerDemo->FFmpegStop();
734 ASSERT_EQ(Plugin::Status::OK, ret);
735
736 ret = muxerDemo->FFmpegDestroy();
737 ASSERT_EQ(Plugin::Status::OK, ret);
738
739 close(g_inputFile);
740 close(fd);
741 delete muxerDemo;
742 }
743
744 /**
745 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_005
746 * @tc.name : mp4(video audio length not equal)
747 * @tc.desc : Function test
748 */
749 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_005, TestSize.Level2)
750 {
751 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
752
753 OutputFormat format = OUTPUT_FORMAT_MPEG_4;
754 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "FUNCTION_005");
755
756 g_inputFile = open("avDataMpegMpeg4.bin", O_RDONLY);
757
758 muxerDemo->FFmpegCreate(fd);
759 Plugin::Status ret;
760
761 int32_t audioTrackId;
762 AddAudioTrack(muxerDemo, audioTrackId);
763 int32_t videoTrackId;
764 AddVideoTrack(muxerDemo, videoTrackId);
765
766 cout << "audio track id is: " << audioTrackId << ", video track id is: " << videoTrackId << endl;
767
768 ret = muxerDemo->FFmpegStart();
769 ASSERT_EQ(Plugin::Status::OK, ret);
770
771 WriteTrackSampleShort(muxerDemo, audioTrackId, videoTrackId, 100);
772
773 ret = muxerDemo->FFmpegStop();
774 ASSERT_EQ(Plugin::Status::OK, ret);
775
776 ret = muxerDemo->FFmpegDestroy();
777 ASSERT_EQ(Plugin::Status::OK, ret);
778
779 close(g_inputFile);
780 close(fd);
781 delete muxerDemo;
782 }
783
784 /**
785 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_006
786 * @tc.name : m4a(thread)
787 * @tc.desc : Function test
788 */
789 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_006, TestSize.Level2)
790 {
791 vector<thread> threadVec;
792 OutputFormat format = OUTPUT_FORMAT_M4A;
793 for (int i = 0; i < 10; i++) {
794 threadVec.push_back(thread(runMuxer, "FUNCTION_006", i, format));
795 }
796 for (uint32_t i = 0; i < threadVec.size(); i++) {
797 threadVec[i].join();
798 }
799 for (int32_t i = 0; i < 10; i++)
800 {
801 ASSERT_EQ(Plugin::Status::OK, g_testResult[i]);
802 }
803 }
804
805 /**
806 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_007
807 * @tc.name : mp4(thread)
808 * @tc.desc : Function test
809 */
810 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_007, TestSize.Level2)
811 {
812 vector<thread> threadVec;
813 OutputFormat format = OUTPUT_FORMAT_MPEG_4;
814 for (int i = 0; i < 10; i++) {
815 threadVec.push_back(thread(runMuxer, "SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_007", i, format));
816 }
817 for (uint32_t i = 0; i < threadVec.size(); i++) {
818 threadVec[i].join();
819 }
820 for (int32_t i = 0; i < 10; i++)
821 {
822 ASSERT_EQ(Plugin::Status::OK, g_testResult[i]);
823 }
824 }
825
826 /**
827 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_008
828 * @tc.name : m4a(multi audio track)
829 * @tc.desc : Function test
830 */
831 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_008, TestSize.Level2)
832 {
833 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
834
835 OutputFormat format = OUTPUT_FORMAT_M4A;
836 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "FUNCTION_008");
837
838 int32_t audioFileFd1 = open("aac_44100_2.bin", O_RDONLY);
839 int32_t audioFileFd2 = open("aac_44100_2.bin", O_RDONLY);
840
841 muxerDemo->FFmpegCreate(fd);
842
843 int32_t audioTrackId1;
844 int32_t audioTrackId2;
845 AddAudioTrackAACByFd(muxerDemo, audioFileFd1, audioTrackId1);
846 AddAudioTrackAACByFd(muxerDemo, audioFileFd2, audioTrackId2);
847
848 cout << "audiotrack id1 is: " << audioTrackId1 << ", audioTrackId2 is: " << audioTrackId2 << endl;
849
850 Plugin::Status ret;
851
852 ret = muxerDemo->FFmpegStart();
853 ASSERT_EQ(Plugin::Status::OK, ret);
854
855 if (audioTrackId1 >= 0) {
856 WriteSingleTrackSample(muxerDemo, audioTrackId1, audioFileFd1);
857 }
858 if (audioTrackId2 >= 0) {
859 WriteSingleTrackSample(muxerDemo, audioTrackId2, audioFileFd2);
860 }
861
862 ret = muxerDemo->FFmpegStop();
863 ASSERT_EQ(Plugin::Status::OK, ret);
864
865 ret = muxerDemo->FFmpegDestroy();
866 ASSERT_EQ(Plugin::Status::OK, ret);
867
868 close(audioFileFd1);
869 close(audioFileFd2);
870 close(fd);
871 delete muxerDemo;
872 }
873
874 /**
875 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_009
876 * @tc.name : mp4(multi video track)
877 * @tc.desc : Function test
878 */
879 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_009, TestSize.Level2)
880 {
881 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
882
883 OutputFormat format = OUTPUT_FORMAT_MPEG_4;
884 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "FUNCTION_009");
885
886 int32_t videoFileFd1 = open("h264_640_360.bin", O_RDONLY);
887 int32_t videoFileFd2 = open("h264_640_360.bin", O_RDONLY);
888
889 muxerDemo->FFmpegCreate(fd);
890
891 int32_t videoTrackId1;
892 int32_t videoTrackId2;
893 AddVideoTrackH264ByFd(muxerDemo, videoFileFd1, videoTrackId1);
894 AddVideoTrackH264ByFd(muxerDemo, videoFileFd2, videoTrackId2);
895
896 Plugin::Status ret;
897
898 ret = muxerDemo->FFmpegStart();
899 ASSERT_EQ(Plugin::Status::OK, ret);
900
901 if (videoTrackId1 >= 0) {
902 WriteSingleTrackSample(muxerDemo, videoTrackId1, videoFileFd1);
903 }
904 if (videoTrackId2 >= 0) {
905 WriteSingleTrackSample(muxerDemo, videoTrackId2, videoFileFd2);
906 }
907
908 ret = muxerDemo->FFmpegStop();
909 ASSERT_EQ(Plugin::Status::OK, ret);
910
911 ret = muxerDemo->FFmpegDestroy();
912 ASSERT_EQ(Plugin::Status::OK, ret);
913
914 close(videoFileFd1);
915 close(videoFileFd2);
916 close(fd);
917 delete muxerDemo;
918 }
919 /**
920 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_010
921 * @tc.name : m4a(auido video with cover)
922 * @tc.desc : Function test
923 */
924 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_010, TestSize.Level2)
925 {
926 string coverTypeList[] = {"bmp", "jpg", "png"};
927 for (int i = 0; i < 3; i++) {
928 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
929 string outputFile = "FUNCTION_010_" + coverTypeList[i];
930 string coverFile = "greatwall." + coverTypeList[i];
931
932 OutputFormat format = OUTPUT_FORMAT_M4A;
933 int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
934
935 int32_t audioFileFd = open("aac_44100_2.bin", O_RDONLY);
936 int32_t videoFileFd = open("h264_640_360.bin", O_RDONLY);
937 int32_t coverFileFd = open(coverFile.c_str(), O_RDONLY);
938
939 muxerDemo->FFmpegCreate(fd);
940
941 int32_t audioTrackId;
942 int32_t videoTrackId;
943 int32_t coverTrackId = 1;
944
945 AddAudioTrackAACByFd(muxerDemo, audioFileFd, audioTrackId);
946 AddVideoTrackH264ByFd(muxerDemo, videoFileFd, videoTrackId);
947 AddCoverTrack(muxerDemo, coverTypeList[i], coverTrackId);
948
949 cout << "audio track id is: " << audioTrackId << ", video track id is: " << videoTrackId
950 << ", cover track id is: " << coverTrackId << endl;
951
952 Plugin::Status ret;
953
954 ret = muxerDemo->FFmpegStart();
955 ASSERT_EQ(Plugin::Status::OK, ret);
956
957 WriteTrackCover(muxerDemo, coverTrackId, coverFileFd);
958 WriteSingleTrackSample(muxerDemo, audioTrackId, audioFileFd);
959 WriteSingleTrackSample(muxerDemo, videoTrackId, videoFileFd);
960
961 ret = muxerDemo->FFmpegStop();
962 ASSERT_EQ(Plugin::Status::OK, ret);
963
964 ret = muxerDemo->FFmpegDestroy();
965 ASSERT_EQ(Plugin::Status::OK, ret);
966
967 close(audioFileFd);
968 close(videoFileFd);
969 close(coverFileFd);
970 close(fd);
971 delete muxerDemo;
972 }
973 }
974
975 /**
976 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_011
977 * @tc.name : mp4(auido video with cover)
978 * @tc.desc : Function test
979 */
980 HWTEST_F(FFmpegAVMuxerFunctionTest, SUB_MULTIMEDIA_MEDIA_MUXER_FUNCTION_011, TestSize.Level2)
981 {
982 string coverTypeList[] = {"bmp", "jpg", "png"};
983 for (int i = 0; i < 3; i++) {
984 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
985 string outputFile = "FUNCTION_011_" + coverTypeList[i];
986 string coverFile = "greatwall." + coverTypeList[i];
987
988 OutputFormat format = OUTPUT_FORMAT_MPEG_4;
989 int32_t fd = muxerDemo->FFmpeggetFdByMode(format);
990
991 int32_t audioFileFd = open("aac_44100_2.bin", O_RDONLY);
992 int32_t videoFileFd = open("mpeg4_720_480.bin", O_RDONLY);
993 int32_t coverFileFd = open(coverFile.c_str(), O_RDONLY);
994
995 muxerDemo->FFmpegCreate(fd);
996 int32_t audioTrackId;
997 AddAudioTrackAACByFd(muxerDemo, audioFileFd, audioTrackId);
998 int32_t videoTrackId;
999 AddVideoTrackByFd(muxerDemo, videoFileFd, videoTrackId);
1000 int32_t coverTrackId = 1;
1001 AddCoverTrack(muxerDemo, coverTypeList[i], coverTrackId);
1002
1003 cout << "audio track id is: " << audioTrackId << ", cover track id is: " << coverTrackId << endl;
1004
1005 Plugin::Status ret;
1006
1007 ret = muxerDemo->FFmpegStart();
1008 ASSERT_EQ(Plugin::Status::OK, ret);
1009
1010 WriteTrackCover(muxerDemo, coverTrackId, coverFileFd);
1011 WriteSingleTrackSample(muxerDemo, audioTrackId, audioFileFd);
1012 WriteSingleTrackSample(muxerDemo, videoTrackId, videoFileFd);
1013
1014 ret = muxerDemo->FFmpegStop();
1015 ASSERT_EQ(Plugin::Status::OK, ret);
1016
1017 ret = muxerDemo->FFmpegDestroy();
1018 ASSERT_EQ(Plugin::Status::OK, ret);
1019
1020 close(audioFileFd);
1021 close(videoFileFd);
1022 close(coverFileFd);
1023 close(fd);
1024 delete muxerDemo;
1025 }
1026 }
1027