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 <ctime>
21 #include "gtest/gtest.h"
22 #include "AVMuxerDemo.h"
23 #include "fcntl.h"
24 #include "avcodec_info.h"
25 #include "avcodec_errors.h"
26 #include "securec.h"
27
28 using namespace std;
29 using namespace testing::ext;
30 using namespace OHOS;
31 using namespace OHOS::MediaAVCodec;
32 using namespace OHOS::MediaAVCodec::Plugin;
33 using namespace Ffmpeg;
34
35 constexpr int32_t CHANNEL_COUNT = 2;
36 constexpr int32_t SAMPLE_RATE = 44100;
37 constexpr int32_t INFO_SIZE = 100;
38 constexpr int32_t BIG_EXTRA_SIZE = 100;
39 constexpr int32_t WIDTH = 352;
40 constexpr int32_t HEIGHT = 288;
41
42 namespace {
43 class FFmpegAVMuxerStablityTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp() override;
48 void TearDown() override;
49 };
50
SetUpTestCase()51 void FFmpegAVMuxerStablityTest::SetUpTestCase() {}
TearDownTestCase()52 void FFmpegAVMuxerStablityTest::TearDownTestCase() {}
SetUp()53 void FFmpegAVMuxerStablityTest::SetUp() {}
TearDown()54 void FFmpegAVMuxerStablityTest::TearDown() {}
55
56 static int g_inputFile = -1;
57 static const int DATA_AUDIO_ID = 0;
58 static const int DATA_VIDEO_ID = 1;
59
60 constexpr int RUN_TIMES = 1000;
61 constexpr int RUN_TIME = 8 * 3600;
62
63 Status g_testResult[10] = { Plugin::Status::ERROR_UNKNOWN };
64
SetRotation(AVMuxerDemo * muxerDemo)65 Status SetRotation(AVMuxerDemo *muxerDemo)
66 {
67 int32_t rotation = 0;
68 return muxerDemo->FFmpegSetRotation(rotation);
69 }
70
AddTrack(AVMuxerDemo * muxerDemo,int32_t & trackIndex)71 Status AddTrack(AVMuxerDemo *muxerDemo, int32_t &trackIndex)
72 {
73 MediaDescription audioParams;
74 audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
75 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
76 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
77
78 return muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
79 }
80
WriteSample(AVMuxerDemo * muxerDemo,uint32_t trackIndex)81 Status WriteSample(AVMuxerDemo *muxerDemo, uint32_t trackIndex)
82 {
83 uint8_t data[100];
84
85 AVCodecBufferInfo info;
86 AVCodecBufferFlag flag;
87 info.presentationTimeUs = 0;
88 info.size = INFO_SIZE;
89 flag = AVCODEC_BUFFER_FLAG_NONE;
90 info.offset = 0;
91
92 return muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
93 }
94
AddAudioTrack(AVMuxerDemo * muxerDemo,int32_t & trackIndex)95 Status AddAudioTrack(AVMuxerDemo *muxerDemo, int32_t &trackIndex)
96 {
97 MediaDescription audioParams;
98
99 int extraSize = 0;
100 unsigned char buffer[100] = {0};
101
102 read(g_inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
103 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
104 read(g_inputFile, buffer, extraSize);
105 audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, buffer, extraSize);
106 }
107 audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_MPEG);
108 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
109 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
110
111 Status ret = muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
112
113 return ret;
114 }
115
AddAudioTrackAAC(AVMuxerDemo * muxerDemo,int32_t & trackIndex)116 Status AddAudioTrackAAC(AVMuxerDemo *muxerDemo, int32_t &trackIndex)
117 {
118 MediaDescription audioParams;
119
120 int extraSize = 0;
121 unsigned char buffer[100] = {0};
122
123 read(g_inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
124 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
125 read(g_inputFile, buffer, extraSize);
126 audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, buffer, extraSize);
127 }
128 audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
129 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
130 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
131
132 Status ret = muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
133
134 return ret;
135 }
136
AddVideoTrack(AVMuxerDemo * muxerDemo,int32_t & trackIndex)137 Status AddVideoTrack(AVMuxerDemo *muxerDemo, int32_t &trackIndex)
138 {
139 MediaDescription videoParams;
140
141 int extraSize = 0;
142 unsigned char buffer[100] = {0};
143
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 videoParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, static_cast<uint8_t*>buffer, extraSize);
148 }
149 videoParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_MPEG4);
150 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, WIDTH);
151 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, HEIGHT);
152
153 Status ret = muxerDemo->FFmpegAddTrack(trackIndex, videoParams);
154
155 return ret;
156 }
157
RemoveHeader()158 void RemoveHeader()
159 {
160 int extraSize = 0;
161 unsigned char buffer[100] = {0};
162 read(g_inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
163 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
164 read(g_inputFile, buffer, extraSize);
165 }
166 }
167
WriteTrackSample(AVMuxerDemo * muxerDemo,int audioTrackIndex,int videoTrackIndex)168 void WriteTrackSample(AVMuxerDemo *muxerDemo, int audioTrackIndex, int videoTrackIndex)
169 {
170 int dataTrackId = 0;
171 int dataSize = 0;
172 int ret = 0;
173 int trackId = 0;
174 AVCodecBufferInfo info;
175 uint32_t trackIndex;
176 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
177 uint8_t data[1024 * 1024] = {0};
178 while (1) {
179 ret = read(g_inputFile, static_cast<void*>(&dataTrackId), sizeof(dataTrackId));
180 if (ret <= 0) {
181 cout << "read dataTrackId error, ret is: " << (int)ret << endl;
182 return;
183 }
184 ret = read(g_inputFile, static_cast<void*>(&info.presentationTimeUs), sizeof(info.presentationTimeUs));
185 if (ret <= 0) {
186 cout << "read info.presentationTimeUs error, ret is: " << (int)ret << endl;
187 return;
188 }
189 ret = read(g_inputFile, static_cast<void*>(&dataSize), sizeof(dataSize));
190 if (ret <= 0) {
191 cout << "read dataSize error, ret is: " << (int)ret << endl;
192 return;
193 }
194 ret = read(g_inputFile, static_cast<void*>data, dataSize);
195 if (ret <= 0) {
196 cout << "read data error, ret is: " << (int)ret << endl;
197 return;
198 }
199
200 info.size = dataSize;
201 if (dataTrackId == DATA_AUDIO_ID) {
202 trackId = audioTrackIndex;
203 } else if (dataTrackId == DATA_VIDEO_ID) {
204 trackId = videoTrackIndex;
205 } else {
206 cout << "error dataTrackId : " << trackId << endl;
207 }
208 if (trackId >= 0) {
209 trackIndex = trackId;
210 Status result = muxerDemo->FFmpegWriteSample(trackIndex, data, info, flag);
211 if (result != Status::OK) {
212 return;
213 }
214 }
215 }
216 }
217
AddAudioTrackByFd(AVMuxerDemo * muxerDemo,int32_t inputFile,int32_t & trackIndex)218 Status AddAudioTrackByFd(AVMuxerDemo *muxerDemo, int32_t inputFile, int32_t &trackIndex)
219 {
220 MediaDescription audioParams;
221
222 int extraSize = 0;
223 unsigned char buffer[100] = {0};
224
225 read(inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
226 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
227 read(inputFile, buffer, extraSize);
228 audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, (uint8_t *)buffer, extraSize);
229 }
230 audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_MPEG);
231 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
232 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
233
234 Status ret = muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
235
236 return ret;
237 }
238
AddAudioTrackAACByFd(AVMuxerDemo * muxerDemo,int32_t inputFile,int32_t & trackIndex)239 Status AddAudioTrackAACByFd(AVMuxerDemo *muxerDemo, int32_t inputFile, int32_t &trackIndex)
240 {
241 MediaDescription audioParams;
242
243 int extraSize = 0;
244 unsigned char buffer[100] = {0};
245
246 read(inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
247 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
248 read(inputFile, buffer, extraSize);
249 audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, (uint8_t *)buffer, extraSize);
250 }
251 audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
252 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, CHANNEL_COUNT);
253 audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE);
254
255 Status ret = muxerDemo->FFmpegAddTrack(trackIndex, audioParams);
256
257 return ret;
258 }
259
AddVideoTrackByFd(AVMuxerDemo * muxerDemo,int32_t inputFile,int32_t & trackIndex)260 Status AddVideoTrackByFd(AVMuxerDemo *muxerDemo, int32_t inputFile, int32_t &trackIndex)
261 {
262 MediaDescription videoParams;
263
264 int extraSize = 0;
265 unsigned char buffer[100] = {0};
266
267 read(inputFile, static_cast<void*>(&extraSize), sizeof(extraSize));
268 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
269 read(inputFile, buffer, extraSize);
270 videoParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, (uint8_t *)buffer, extraSize);
271 }
272 videoParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::VIDEO_MPEG4);
273 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, WIDTH);
274 videoParams.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, HEIGHT);
275
276 Status ret = muxerDemo->FFmpegAddTrack(trackIndex, videoParams);
277
278 return ret;
279 }
280
WriteTrackSampleByFdRead(int32_t * inputFile,AVCodecBufferInfo * info,int * dataSize,int * dataTrackId)281 int WriteTrackSampleByFdRead(int32_t *inputFile, AVCodecBufferInfo *info, int *dataSize, int *dataTrackId)
282 {
283 int ret = read(*inputFile, static_cast<void*>dataTrackId, sizeof(*dataTrackId));
284 if (ret <= 0) {
285 return -1;
286 }
287 ret = read(*inputFile, static_cast<void*>(&info->presentationTimeUs), sizeof(info->presentationTimeUs));
288 if (ret <= 0) {
289 return -1;
290 }
291 ret = read(*inputFile, static_cast<void*>dataSize, sizeof(*dataSize));
292 if (ret <= 0) {
293 return -1;
294 }
295 return 0;
296 }
297
WriteTrackSampleByFdMem(int * dataSize,unsigned char * avMuxerDemoBuffer,int * avMuxerDemoBufferSize)298 int WriteTrackSampleByFdMem(int *dataSize, unsigned char *avMuxerDemoBuffer, int *avMuxerDemoBufferSize)
299 {
300 if (avMuxerDemoBuffer != nullptr && *dataSize > *avMuxerDemoBufferSize) {
301 free(avMuxerDemoBuffer);
302 *avMuxerDemoBufferSize = 0;
303 avMuxerDemoBuffer = nullptr;
304 }
305 if (avMuxerDemoBuffer == nullptr) {
306 avMuxerDemoBuffer = static_cast<unsigned char*>malloc(*dataSize);
307 *avMuxerDemoBufferSize = *dataSize;
308 if (avMuxerDemoBuffer == nullptr) {
309 printf("error malloc memory!\n");
310 return -1;
311 }
312 }
313 return 0;
314 }
315
WriteTrackSampleByFd(AVMuxerDemo * muxerDemo,int audioTrackIndex,int videoTrackIndex,int32_t inputFile)316 void WriteTrackSampleByFd(AVMuxerDemo *muxerDemo, int audioTrackIndex, int videoTrackIndex, int32_t inputFile)
317 {
318 int dataTrackId = 0, dataSize = 0, ret = 0, trackId = 0;
319 AVCodecBufferInfo info;
320 uint32_t trackIndex;
321 AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
322 unsigned char *avMuxerDemoBuffer = nullptr;
323 int avMuxerDemoBufferSize = 0;
324 string resultStr = "";
325 while (1) {
326 ret = WriteTrackSampleByFdRead(&inputFile, &info, &dataSize, &dataTrackId);
327 if (ret != 0) {
328 break;
329 }
330
331 ret = WriteTrackSampleByFdMem(&dataSize, avMuxerDemoBuffer, &avMuxerDemoBufferSize);
332 if (ret != 0) {
333 break;
334 }
335
336 resultStr =
337 "inputFile is: " + to_string(inputFile) + ", avMuxerDemoBufferSize is " + to_string(avMuxerDemoBufferSize);
338 cout << resultStr << endl;
339
340 ret = read(inputFile, static_cast<void*>avMuxerDemoBuffer, dataSize);
341 if (ret <= 0) {
342 cout << "read data error, ret is: " << (int)ret << endl;
343 continue;
344 }
345
346 info.size = dataSize;
347 if (dataTrackId == DATA_AUDIO_ID) {
348 trackId = audioTrackIndex;
349 } else if (dataTrackId == DATA_VIDEO_ID) {
350 trackId = videoTrackIndex;
351 } else {
352 cout << "error dataTrackId : " << dataTrackId << endl;
353 }
354 if (trackId >= 0) {
355 trackIndex = trackId;
356 Status result = muxerDemo->FFmpegWriteSample(trackIndex, avMuxerDemoBuffer, info, flag);
357 if (result != Status::OK) {
358 cout << "OH_AVMuxer_WriteSampleBuffer error! ret is: " << (int)result << endl;
359 break;
360 }
361 }
362 }
363 if (avMuxerDemoBuffer != nullptr) {
364 free(avMuxerDemoBuffer);
365 }
366 }
367
RunMuxer(string testcaseName,int threadId,OutputFormat format)368 void RunMuxer(string testcaseName, int threadId, OutputFormat format)
369 {
370 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
371 time_t startTime = time(nullptr);
372 ASSERT_NE(startTime, -1);
373 time_t curTime = startTime;
374
375 while (difftime(curTime, startTime) < RUN_TIME) {
376 cout << "thread id is: " << threadId << ", run time : " << difftime(curTime, startTime) << " seconds" << endl;
377 string fileName = testcaseName + "_" + to_string(threadId);
378
379 cout << "thread id is: " << threadId << ", cur file name is: " << fileName << endl;
380 int32_t fd = muxerDemo->FFmpeggetFdByName(format, fileName);
381
382 int32_t inputFile;
383 int32_t audioTrackId;
384 int32_t videoTrackId;
385
386 cout << "thread id is: " << threadId << ", fd is: " << fd << endl;
387 muxerDemo->FFmpegCreate(fd);
388
389 Status ret;
390
391 if (format == OUTPUT_FORMAT_MPEG_4) {
392 cout << "thread id is: " << threadId << ", format is: " << format << endl;
393 inputFile = open("avDataMpegMpeg4.bin", O_RDONLY);
394 AddAudioTrackByFd(muxerDemo, inputFile, audioTrackId);
395 AddVideoTrackByFd(muxerDemo, inputFile, videoTrackId);
396 } else {
397 cout << "thread id is: " << threadId << ", format is: " << format << endl;
398 inputFile = open("avData_mpeg4_aac_2.bin", O_RDONLY);
399 AddAudioTrackAACByFd(muxerDemo, inputFile, audioTrackId);
400 videoTrackId = -1;
401 int extraSize = 0;
402 unsigned char buffer[100] = {0};
403 read(inputFile, static_cast<void*>&extraSize, sizeof(extraSize));
404 if (extraSize <= BIG_EXTRA_SIZE && extraSize > 0) {
405 read(inputFile, buffer, extraSize);
406 }
407 }
408
409 cout << "thread id is: " << threadId << ", audio track id is: " << audioTrackId
410 << ", video track id is: " << videoTrackId << endl;
411
412 ret = muxerDemo->FFmpegStart();
413 cout << "thread id is: " << threadId << ", Start ret is:" << (int)ret << endl;
414
415 WriteTrackSampleByFd(muxerDemo, audioTrackId, videoTrackId, inputFile);
416
417 ret = muxerDemo->FFmpegStop();
418 cout << "thread id is: " << threadId << ", Stop ret is:" << (int)ret << endl;
419
420 ret = muxerDemo->FFmpegDestroy();
421 cout << "thread id is: " << threadId << ", Destroy ret is:" << (int)ret << endl;
422
423 close(inputFile);
424 close(fd);
425 curTime = time(nullptr);
426 ASSERT_NE(curTime, -1);
427 }
428 g_testResult[threadId] = Status::OK;
429 delete muxerDemo;
430 }
431 } // namespace
432
433 /**
434 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_001
435 * @tc.name : Create(1000 times)
436 * @tc.desc : Stability test
437 */
438 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_001, TestSize.Level2)
439 {
440 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
441
442 OutputFormat format = OUTPUT_FORMAT_M4A;
443 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_001");
444
445 g_inputFile = open("avData_mpeg4_aac_2.bin", O_RDONLY);
446
447 for (int i = 0; i < RUN_TIMES; i++) {
448 muxerDemo->FFmpegCreate(fd);
449 cout << "run time is: " << i << endl;
450 Plugin::Status ret = muxerDemo->FFmpegDestroy();
451 ASSERT_EQ(Status::OK, ret);
452 }
453
454 close(fd);
455 delete muxerDemo;
456 }
457
458 /**
459 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_002
460 * @tc.name : SetRotation(1000 times)
461 * @tc.desc : Stability test
462 */
463 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_002, TestSize.Level2)
464 {
465 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
466
467 OutputFormat format = OUTPUT_FORMAT_M4A;
468 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_002");
469
470 muxerDemo->FFmpegCreate(fd);
471
472 for (int i = 0; i < RUN_TIMES; i++) {
473 Status ret = SetRotation(muxerDemo);
474 ASSERT_EQ(Status::OK, ret);
475 }
476
477 muxerDemo->FFmpegDestroy();
478
479 close(fd);
480 delete muxerDemo;
481 }
482
483 /**
484 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_003
485 * @tc.name : AddTrack(1000 times)
486 * @tc.desc : Stability test
487 */
488 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_003, TestSize.Level2)
489 {
490 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
491
492 OutputFormat format = OUTPUT_FORMAT_M4A;
493 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_003");
494
495 muxerDemo->FFmpegCreate(fd);
496
497 for (int i = 0; i < RUN_TIMES; i++) {
498 int32_t trackId;
499 Status ret = AddTrack(muxerDemo, trackId);
500 ASSERT_EQ(Status::OK, ret);
501 }
502
503 muxerDemo->FFmpegDestroy();
504
505 close(fd);
506 delete muxerDemo;
507 }
508
509 /**
510 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_004
511 * @tc.name : Start(1000 times)
512 * @tc.desc : Stability test
513 */
514 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_004, TestSize.Level2)
515 {
516 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
517
518 OutputFormat format = OUTPUT_FORMAT_M4A;
519 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_004");
520
521 muxerDemo->FFmpegCreate(fd);
522
523 int32_t trackId;
524 Status ret = AddTrack(muxerDemo, trackId);
525 ASSERT_EQ(Status::OK, ret);
526 ASSERT_EQ(0, trackId);
527
528 for (int i = 0; i < RUN_TIMES; i++) {
529 ret = muxerDemo->FFmpegStart();
530 cout << "run time is: " << i << ", ret is:" << (int)ret << endl;
531 }
532
533 muxerDemo->FFmpegDestroy();
534
535 close(fd);
536 delete muxerDemo;
537 }
538
539 /**
540 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_005
541 * @tc.name : WriteSample(1000 times)
542 * @tc.desc : Stability test
543 */
544 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_005, TestSize.Level2)
545 {
546 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
547
548 OutputFormat format = OUTPUT_FORMAT_M4A;
549 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_005");
550
551 muxerDemo->FFmpegCreate(fd);
552
553 int32_t trackId;
554 Status ret = AddTrack(muxerDemo, trackId);
555 ASSERT_EQ(Status::OK, ret);
556 ASSERT_EQ(0, trackId);
557
558 ret = muxerDemo->FFmpegStart();
559 ASSERT_EQ(Status::OK, ret);
560
561 for (int i = 0; i < RUN_TIMES; i++) {
562 ret = WriteSample(muxerDemo, trackId);
563 cout << "run time is: " << i << ", ret is:" << (int)ret << endl;
564 }
565
566 muxerDemo->FFmpegDestroy();
567
568 close(fd);
569 delete muxerDemo;
570 }
571
572 /**
573 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_006
574 * @tc.name : Stop(1000 times)
575 * @tc.desc : Stability test
576 */
577 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_006, TestSize.Level2)
578 {
579 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
580
581 OutputFormat format = OUTPUT_FORMAT_M4A;
582 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_006");
583
584 muxerDemo->FFmpegCreate(fd);
585
586 int32_t trackId;
587 Status ret = AddTrack(muxerDemo, trackId);
588 ASSERT_EQ(Status::OK, ret);
589 ASSERT_EQ(0, trackId);
590
591 ret = muxerDemo->FFmpegStart();
592 ASSERT_EQ(Status::OK, ret);
593
594 ret = WriteSample(muxerDemo, trackId);
595 ASSERT_EQ(Status::OK, ret);
596
597 for (int i = 0; i < RUN_TIMES; i++) {
598 ret = muxerDemo->FFmpegStop();
599 cout << "run time is: " << i << ", ret is:" << (int)ret << endl;
600 }
601
602 muxerDemo->FFmpegDestroy();
603
604 close(fd);
605 delete muxerDemo;
606 }
607
608 /**
609 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_007
610 * @tc.name : Destroy(1000 times)
611 * @tc.desc : Stability test
612 */
613 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_007, TestSize.Level2)
614 {
615 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
616
617 OutputFormat format = OUTPUT_FORMAT_M4A;
618 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_007");
619
620 muxerDemo->FFmpegCreate(fd);
621
622 for (int i = 0; i < RUN_TIMES; i++) {
623 Status ret = muxerDemo->FFmpegDestroy();
624 ASSERT_EQ(Status::OK, ret);
625 }
626
627 close(fd);
628 delete muxerDemo;
629 }
630
631 /**
632 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_008
633 * @tc.name : m4a(long time)
634 * @tc.desc : Function test
635 */
636 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_008, TestSize.Level2)
637 {
638 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
639 time_t startTime = time(nullptr);
640 ASSERT_NE(startTime, -1);
641 time_t curTime = startTime;
642
643 while (difftime(curTime, startTime) < RUN_TIME) {
644 cout << "run time: " << difftime(curTime, startTime) << " seconds" << endl;
645 OutputFormat format = OUTPUT_FORMAT_M4A;
646 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_008");
647
648 g_inputFile = open("avData_mpeg4_aac_2.bin", O_RDONLY);
649
650 muxerDemo->FFmpegCreate(fd);
651
652 int32_t audioTrackId;
653 Status ret = AddAudioTrackAAC(muxerDemo, audioTrackId);
654 int32_t videoTrackId = -1;
655 RemoveHeader();
656
657 cout << "audio track id is: " << audioTrackId << ", video track id is: " << videoTrackId << endl;
658
659 ret = muxerDemo->FFmpegStart();
660 cout << "Start ret is:" << (int)ret << endl;
661
662 WriteTrackSample(muxerDemo, audioTrackId, videoTrackId);
663
664 ret = muxerDemo->FFmpegStop();
665 cout << "Stop ret is:" << (int)ret << endl;
666
667 ret = muxerDemo->FFmpegDestroy();
668 cout << "Destroy ret is:" << (int)ret << endl;
669
670 close(g_inputFile);
671 close(fd);
672 curTime = time(nullptr);
673 ASSERT_NE(curTime, -1);
674 }
675 delete muxerDemo;
676 }
677
678 /**
679 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_009
680 * @tc.name : mp4(long time)
681 * @tc.desc : Function test
682 */
683 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_009, TestSize.Level2)
684 {
685 AVMuxerDemo *muxerDemo = new AVMuxerDemo();
686 time_t startTime = time(nullptr);
687 ASSERT_NE(startTime, -1);
688 time_t curTime = startTime;
689
690 while (difftime(curTime, startTime) < RUN_TIME) {
691 cout << "run time: " << difftime(curTime, startTime) << " seconds" << endl;
692
693 OutputFormat format = OUTPUT_FORMAT_MPEG_4;
694 int32_t fd = muxerDemo->FFmpeggetFdByName(format, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_009");
695
696 g_inputFile = open("avDataMpegMpeg4.bin", O_RDONLY);
697
698 muxerDemo->FFmpegCreate(fd);
699
700 int32_t audioTrackId;
701 Status ret = AddAudioTrack(muxerDemo, audioTrackId);
702 int32_t videoTrackId;
703 ret = AddVideoTrack(muxerDemo, videoTrackId);
704
705 cout << "audio track id is: " << audioTrackId << ", video track id is: " << videoTrackId << endl;
706
707 ret = muxerDemo->FFmpegStart();
708 cout << "Start ret is:" << (int)ret << endl;
709
710 WriteTrackSample(muxerDemo, audioTrackId, videoTrackId);
711
712 ret = muxerDemo->FFmpegStop();
713 cout << "Stop ret is:" << (int)ret << endl;
714
715 ret = muxerDemo->FFmpegDestroy();
716 cout << "Destroy ret is:" << (int)ret << endl;
717
718 close(g_inputFile);
719 close(fd);
720 curTime = time(nullptr);
721 ASSERT_NE(curTime, -1);
722 }
723 delete muxerDemo;
724 }
725
726 /**
727 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_010
728 * @tc.name : m4a(thread long time)
729 * @tc.desc : Function test
730 */
731 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_010, TestSize.Level2)
732 {
733 vector<thread> threadVec;
734 OutputFormat format = OUTPUT_FORMAT_M4A;
735 for (int i = 0; i < 16; i++) {
736 threadVec.push_back(thread(RunMuxer, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_010", i, format));
737 }
738 for (uint32_t i = 0; i < threadVec.size(); i++) {
739 threadVec[i].join();
740 }
741 for (int32_t i = 0; i < 10; i++)
742 {
743 ASSERT_EQ(Status::OK, g_testResult[i]);
744 }
745 }
746
747 /**
748 * @tc.number : SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_011
749 * @tc.name : mp4(thread long time)
750 * @tc.desc : Function test
751 */
752 HWTEST_F(FFmpegAVMuxerStablityTest, SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_011, TestSize.Level2)
753 {
754 vector<thread> threadVec;
755 OutputFormat format = OUTPUT_FORMAT_MPEG_4;
756 for (int i = 0; i < 16; i++) {
757 threadVec.push_back(thread(RunMuxer, "SUB_MULTIMEDIA_MEDIA_MUXER_STABILITY_011", i, format));
758 }
759 for (uint32_t i = 0; i < threadVec.size(); i++) {
760 threadVec[i].join();
761 }
762 for (int32_t i = 0; i < 10; i++)
763 {
764 ASSERT_EQ(Status::OK, g_testResult[i]);
765 }
766 }