• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 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 <cstddef>
17 #include <cstdint>
18 #include <fcntl.h>
19 #include <unistd.h>
20 #include <sys/stat.h>
21 #include "securec.h"
22 #include <string>
23 #include <malloc.h>
24 #include <sys/stat.h>
25 #include <cinttypes>
26 #include <thread>
27 #include <chrono>
28 #include "plugin/plugin_event.h"
29 #include "demuxer/stream_demuxer.h"
30 #include <iostream>
31 #include "mediademuxer_mock_fuzz.h"
32 
33 #include "media_demuxer.h"
34 
35 #define FUZZ_PROJECT_NAME "mediademuxer_fuzzer"
36 using namespace std;
37 using namespace OHOS::Media;
38 
39 namespace OHOS {
40 namespace Media {
41 const int NUMBER_1 = 1;
42 const int NUMBER_2 = 2;
43 const int NUMBER_3 = 3;
44 const int NUMBER_4 = 4;
45 const int NUMBER_5 = 5;
46 const int NUMBER_8 = 8;
47 const int NUMBER_10 = 10;
48 const int NUMBER_25 = 25;
49 const int NUMBER_100 = 100;
50 const int NUMBER_111 = 111;
51 const int NUMBER_200 = 200;
52 const float NUMBER_SPEED = 111.5;
53 const double NUMBER_FRAMERATE_1 = 1.5;
54 const double NUMBER_FRAMERATE_2 = 15000;
55 const char *DATA_PATH = "/data/test/fuzz_create.mp4";
56 void DoFuzzTest();
57 void FuzzTest1();
58 void FuzzTest6();
59 void FuzzTest7();
60 void FuzzTest8();
61 void FuzzTest9();
62 void FuzzTest10();
63 void FuzzTest11();
64 void FuzzTest12();
65 void FuzzTest13();
66 void FuzzTest14();
67 void FuzzTest15();
68 void FuzzTest16();
69 void FuzzTest17();
70 void FuzzTest18();
71 void FuzzTest19();
72 void FuzzTest20();
73 void FuzzTest21();
74 void FuzzTest22();
75 void FuzzTest23();
76 void FuzzTest24();
77 void FuzzTest25();
78 void FuzzTest27();
79 void FuzzTest28();
80 void FuzzTest29();
81 void FuzzTest30();
82 void FuzzTest31();
83 void FuzzTest32();
84 void FuzzTest33();
85 void FuzzTest34();
86 void FuzzTest35();
87 void FuzzTest37();
88 void FuzzTest38();
89 void FuzzTest39();
90 void FuzzTest40();
91 void FuzzTest41();
92 void FuzzTest45();
93 void FuzzTest46();
94 void FuzzTest47();
95 void FuzzTest48();
96 void FuzzTest49();
97 void FuzzTest50();
98 void FuzzTest51();
99 void FuzzTest52();
100 void FuzzTest53();
101 void FuzzTest54();
102 class MediaDemuxerTestCallback : public OHOS::MediaAVCodec::AVDemuxerCallback {
103 public:
MediaDemuxerTestCallback()104     explicit MediaDemuxerTestCallback()
105     {
106     }
107 
~MediaDemuxerTestCallback()108     ~MediaDemuxerTestCallback()
109     {
110     }
111 
OnDrmInfoChanged(const std::multimap<std::string,std::vector<uint8_t>> & drmInfo)112     void OnDrmInfoChanged(const std::multimap<std::string, std::vector<uint8_t>> &drmInfo) override
113     {
114     }
115 };
116 
117 class TestEventReceiver : public Pipeline::EventReceiver {
118 public:
TestEventReceiver()119     explicit TestEventReceiver()
120     {
121     }
122 
OnEvent(const Event & event)123     void OnEvent(const Event &event)
124     {
125     }
126 };
127 
128 class VideoStreamReadyTestCallback : public VideoStreamReadyCallback {
129 public:
IsVideoStreamDiscardable(const std::shared_ptr<AVBuffer> buffer)130     bool IsVideoStreamDiscardable(const std::shared_ptr<AVBuffer> buffer)
131     {
132         (void)buffer;
133         return true;
134     }
135 
136 protected:
137 };
138 
RunMediaDemuxerFuzz(uint8_t * data,size_t size)139 bool RunMediaDemuxerFuzz(uint8_t *data, size_t size)
140 {
141     if (size < sizeof(int64_t)) {
142         return false;
143     }
144     int32_t fd = open(DATA_PATH, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
145     if (fd < 0) {
146         return false;
147     }
148     int len = write(fd, data, size);
149     if (len <= 0) {
150         close(fd);
151         return false;
152     }
153     close(fd);
154 
155     FuzzTest1();
156     FuzzTest6();
157     FuzzTest7();
158     FuzzTest8();
159     FuzzTest9();
160     FuzzTest10();
161     FuzzTest11();
162     FuzzTest12();
163     FuzzTest13();
164     FuzzTest14();
165     FuzzTest15();
166     FuzzTest16();
167     FuzzTest17();
168     FuzzTest18();
169     FuzzTest19();
170     FuzzTest20();
171     FuzzTest21();
172     FuzzTest22();
173     FuzzTest23();
174     FuzzTest24();
175     FuzzTest25();
176     FuzzTest27();
177     FuzzTest28();
178     FuzzTest29();
179     FuzzTest30();
180     DoFuzzTest();
181     unlink(DATA_PATH);
182     return true;
183 }
184 
DoFuzzTest()185 void DoFuzzTest()
186 {
187     FuzzTest31();
188     FuzzTest32();
189     FuzzTest33();
190     FuzzTest34();
191     FuzzTest35();
192     FuzzTest37();
193     FuzzTest38();
194     FuzzTest39();
195     FuzzTest40();
196     FuzzTest41();
197     FuzzTest45();
198     FuzzTest46();
199     FuzzTest47();
200     FuzzTest48();
201     FuzzTest49();
202     FuzzTest50();
203     FuzzTest51();
204     FuzzTest52();
205     FuzzTest53();
206     FuzzTest54();
207 }
208 
FuzzTest1()209 void FuzzTest1()
210 {
211     int32_t fd = open(DATA_PATH, O_RDONLY);
212     struct stat statBuffer;
213     if (fstat(fd, &statBuffer) == -1) {
214         perror("Error getting file status");
215         close(fd);
216         return;
217     }
218 
219     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
220     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
221     std::shared_ptr<MediaSource> source = std::make_shared<MediaSource>(uri);
222     Status ret = demuxer->SetDataSource(source);
223     if (ret != Status::OK) {
224         close(fd);
225         return;
226     }
227     demuxer->OnInterrupted(false);
228     demuxer->SetBundleName("fuzzTest");
229 
230     std::shared_ptr<AVBufferQueue> inputQueue =
231             AVBufferQueue::Create(NUMBER_4, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
232     sptr<AVBufferQueueProducer> producer = inputQueue->GetProducer();
233     demuxer->SetOutputBufferQueue(0, producer);
234     auto queueMap = demuxer->GetBufferQueueProducerMap();
235     close(fd);
236     return;
237 }
238 
FuzzTest6()239 void FuzzTest6()
240 {
241     int32_t fd = open(DATA_PATH, O_RDONLY);
242     struct stat statBuffer;
243     if (fstat(fd, &statBuffer) == -1) {
244         perror("Error getting file status");
245         close(fd);
246     }
247     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
248 
249     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
250     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
251     std::shared_ptr<AVBufferQueue> inputBufferQueue =
252         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
253     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
254     demuxer->SetOutputBufferQueue(0, inputBufferQueueProducer);
255     demuxer->SetDecoderFramerateUpperLimit(NUMBER_111, 0);
256     demuxer->SetSpeed(NUMBER_SPEED);
257     demuxer->SetFrameRate(1, NUMBER_25);
258     demuxer->DisableMediaTrack(Plugins::MediaType::VIDEO);
259     demuxer->IsRenderNextVideoFrameSupported();
260     close(fd);
261 }
262 
FuzzTest7()263 void FuzzTest7()
264 {
265     int32_t fd = open(DATA_PATH, O_RDONLY);
266     struct stat statBuffer;
267     if (fstat(fd, &statBuffer) == -1) {
268         perror("Error getting file status");
269         close(fd);
270     }
271     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
272 
273     int32_t trackId = 0;
274     int32_t invalidTrackId = NUMBER_100;
275     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
276     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
277     std::shared_ptr<AVBufferQueue> inputBufferQueue =
278         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
279     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
280     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
281     demuxer->SetTrackNotifyFlag(invalidTrackId, true);
282     demuxer->SetTrackNotifyFlag(trackId, true);
283     demuxer->OnBufferAvailable(trackId);
284     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
285     close(fd);
286 }
287 
FuzzTest8()288 void FuzzTest8()
289 {
290     int32_t fd = open(DATA_PATH, O_RDONLY);
291     struct stat statBuffer;
292     if (fstat(fd, &statBuffer) == -1) {
293         perror("Error getting file status");
294         close(fd);
295     }
296     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
297 
298     int32_t trackId = 0;
299     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
300     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
301     std::shared_ptr<AVBufferQueue> inputBufferQueue =
302         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
303     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
304     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
305     std::shared_ptr<MediaDemuxerTestCallback> callback = std::make_shared<MediaDemuxerTestCallback>();
306     demuxer->SetDrmCallback(callback);
307     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
308     close(fd);
309 }
310 
FuzzTest9()311 void FuzzTest9()
312 {
313     int32_t fd = open(DATA_PATH, O_RDONLY);
314     struct stat statBuffer;
315     if (fstat(fd, &statBuffer) == -1) {
316         perror("Error getting file status");
317         close(fd);
318     }
319     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
320 
321     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
322     int64_t duration = 0;
323     demuxer->mediaMetaData_.globalMeta = std::make_shared<Meta>();
324     demuxer->GetDuration(duration);
325     close(fd);
326 }
327 
FuzzTest10()328 void FuzzTest10()
329 {
330     int32_t fd = open(DATA_PATH, O_RDONLY);
331     struct stat statBuffer;
332     if (fstat(fd, &statBuffer) == -1) {
333         perror("Error getting file status");
334         close(fd);
335     }
336     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
337 
338     int32_t trackId = 0;
339     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
340     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
341     std::shared_ptr<AVBufferQueue> inputBufferQueue =
342         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
343     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
344     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
345     close(fd);
346 }
347 
FuzzTest11()348 void FuzzTest11()
349 {
350     int32_t fd = open(DATA_PATH, O_RDONLY);
351     struct stat statBuffer;
352     if (fstat(fd, &statBuffer) == -1) {
353         perror("Error getting file status");
354         close(fd);
355     }
356     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
357 
358     int32_t trackId = 0;
359     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
360     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
361     std::shared_ptr<AVBufferQueue> inputBufferQueue =
362         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
363     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
364     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
365     demuxer->AddDemuxerCopyTask(trackId, TaskType::GLOBAL);
366     close(fd);
367 }
368 
FuzzTest12()369 void FuzzTest12()
370 {
371     int32_t fd = open(DATA_PATH, O_RDONLY);
372     struct stat statBuffer;
373     if (fstat(fd, &statBuffer) == -1) {
374         perror("Error getting file status");
375         close(fd);
376     }
377     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
378 
379     int32_t trackId = 0;
380     int32_t invalidTrackId = NUMBER_100;
381     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
382     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
383     std::shared_ptr<AVBufferQueue> inputBufferQueue =
384         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
385     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
386     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
387     demuxer->bufferQueueMap_.erase(trackId);
388     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
389     demuxer->AddDemuxerCopyTask(invalidTrackId, TaskType::GLOBAL);
390     demuxer->bufferQueueMap_.insert(
391         std::pair<int32_t, sptr<AVBufferQueueProducer>>(invalidTrackId, inputBufferQueueProducer));
392     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
393     close(fd);
394 }
395 
FuzzTest13()396 void FuzzTest13()
397 {
398     int32_t fd = open(DATA_PATH, O_RDONLY);
399     struct stat statBuffer;
400     if (fstat(fd, &statBuffer) == -1) {
401         perror("Error getting file status");
402         close(fd);
403     }
404     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
405 
406     int32_t trackId = 0;
407     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
408     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
409     std::shared_ptr<AVBufferQueue> inputBufferQueue =
410         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
411     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
412     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
413     demuxer->OnDumpInfo(-1);
414     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
415     close(fd);
416 }
417 
FuzzTest14()418 void FuzzTest14()
419 {
420     int32_t fd = open(DATA_PATH, O_RDONLY);
421     struct stat statBuffer;
422     if (fstat(fd, &statBuffer) == -1) {
423         perror("Error getting file status");
424         close(fd);
425     }
426     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
427 
428     int32_t trackId = 0;
429     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
430     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
431     std::shared_ptr<AVBufferQueue> inputBufferQueue =
432         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
433     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
434     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
435     demuxer->useBufferQueue_ = true;
436     demuxer->SelectTrack(trackId);
437     demuxer->UnselectTrack(trackId);
438     close(fd);
439 }
440 
FuzzTest15()441 void FuzzTest15()
442 {
443     int32_t fd = open(DATA_PATH, O_RDONLY);
444     struct stat statBuffer;
445     if (fstat(fd, &statBuffer) == -1) {
446         perror("Error getting file status");
447         close(fd);
448     }
449     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
450 
451     int32_t trackId = 0;
452     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
453     int64_t realSeekTime = 0;
454     demuxer->SeekTo(0, SeekMode::SEEK_CLOSEST_INNER, realSeekTime);
455     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
456     std::shared_ptr<AVBufferQueue> inputBufferQueue =
457         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
458     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
459     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
460     demuxer->SeekTo(0, SeekMode::SEEK_CLOSEST_INNER, realSeekTime);
461     close(fd);
462 }
463 
FuzzTest16()464 void FuzzTest16()
465 {
466     int32_t fd = open(DATA_PATH, O_RDONLY);
467     struct stat statBuffer;
468     if (fstat(fd, &statBuffer) == -1) {
469         perror("Error getting file status");
470         close(fd);
471     }
472     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
473 
474     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
475     demuxer->isSelectBitRate_.store(true);
476     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
477     demuxer->SelectBitRate(0);
478     close(fd);
479 }
480 
FuzzTest17()481 void FuzzTest17()
482 {
483     int32_t fd = open(DATA_PATH, O_RDONLY);
484     struct stat statBuffer;
485     if (fstat(fd, &statBuffer) == -1) {
486         perror("Error getting file status");
487         close(fd);
488     }
489     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
490 
491     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
492     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
493     demuxer->isSelectBitRate_.store(true);
494     demuxer->SelectBitRate(0);
495     close(fd);
496 }
497 
FuzzTest18()498 void FuzzTest18()
499 {
500     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
501     demuxer->videoTrackId_ = 0;
502     demuxer->audioTrackId_ = NUMBER_1;
503     demuxer->subtitleTrackId_ = NUMBER_2;
504     demuxer->IsRightMediaTrack(MediaDemuxer::TRACK_ID_INVALID, DemuxerTrackType::VIDEO);
505     demuxer->IsRightMediaTrack(0, DemuxerTrackType::VIDEO);
506     demuxer->IsRightMediaTrack(NUMBER_1, DemuxerTrackType::AUDIO);
507     demuxer->IsRightMediaTrack(NUMBER_2, DemuxerTrackType::SUBTITLE);
508 }
509 
FuzzTest19()510 void FuzzTest19()
511 {
512     int32_t fd = open(DATA_PATH, O_RDONLY);
513     struct stat statBuffer;
514     if (fstat(fd, &statBuffer) == -1) {
515         perror("Error getting file status");
516         close(fd);
517     }
518     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
519 
520     int32_t trackId = 0;
521     int32_t invalidTrackId = NUMBER_100;
522     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
523     demuxer->Flush();
524     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
525     std::shared_ptr<AVBufferQueue> inputBufferQueue =
526         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
527     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
528     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
529     demuxer->bufferQueueMap_.insert(
530         std::pair<int32_t, sptr<AVBufferQueueProducer>>(invalidTrackId, inputBufferQueueProducer));
531     demuxer->Flush();
532     close(fd);
533 }
534 
FuzzTest20()535 void FuzzTest20()
536 {
537     int32_t fd = open(DATA_PATH, O_RDONLY);
538     struct stat statBuffer;
539     if (fstat(fd, &statBuffer) == -1) {
540         perror("Error getting file status");
541         close(fd);
542     }
543     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
544 
545     int32_t invalidTrackId = NUMBER_100;
546     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
547     demuxer->taskMap_[invalidTrackId] = nullptr;
548     demuxer->PauseAllTask();
549     demuxer->source_ = nullptr;
550     demuxer->StopAllTask();
551     close(fd);
552 }
553 
FuzzTest21()554 void FuzzTest21()
555 {
556     int32_t fd = open(DATA_PATH, O_RDONLY);
557     struct stat statBuffer;
558     if (fstat(fd, &statBuffer) == -1) {
559         perror("Error getting file status");
560         close(fd);
561     }
562     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
563 
564     int32_t trackId = 0;
565     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
566     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
567     demuxer->Resume();
568     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
569     std::shared_ptr<AVBufferQueue> inputBufferQueue =
570         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
571     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
572     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
573     close(fd);
574 }
575 
FuzzTest22()576 void FuzzTest22()
577 {
578     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
579 
580     demuxer->streamDemuxer_ = nullptr;
581     demuxer->source_ = nullptr;
582     demuxer->inPreroll_.store(true);
583     demuxer->Resume();
584 
585     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
586     demuxer->inPreroll_.store(false);
587     demuxer->Resume();
588 }
589 
FuzzTest23()590 void FuzzTest23()
591 {
592     int32_t fd = open(DATA_PATH, O_RDONLY);
593     struct stat statBuffer;
594     if (fstat(fd, &statBuffer) == -1) {
595         perror("Error getting file status");
596         close(fd);
597     }
598     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
599 
600     int32_t trackId = 0;
601     int32_t invalidTrackId = 0;
602     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
603     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
604     std::shared_ptr<AVBufferQueue> inputBufferQueue =
605         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
606     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
607     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
608     demuxer->taskMap_[invalidTrackId] = nullptr;
609     demuxer->Start();
610     close(fd);
611 }
612 
FuzzTest24()613 void FuzzTest24()
614 {
615     int32_t fd = open(DATA_PATH, O_RDONLY);
616     struct stat statBuffer;
617     if (fstat(fd, &statBuffer) == -1) {
618         perror("Error getting file status");
619         close(fd);
620     }
621     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
622 
623     int32_t trackId = 0;
624     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
625     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
626     std::shared_ptr<AVBufferQueue> inputBufferQueue =
627         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
628     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
629     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
630     close(fd);
631 }
632 
FuzzTest25()633 void FuzzTest25()
634 {
635     int32_t fd = open(DATA_PATH, O_RDONLY);
636     struct stat statBuffer;
637     if (fstat(fd, &statBuffer) == -1) {
638         perror("Error getting file status");
639         close(fd);
640     }
641     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
642 
643     int32_t aTrackId = 0;
644     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
645     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
646     std::shared_ptr<AVBufferQueue> inputBufferQueue =
647         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
648     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
649     demuxer->SetOutputBufferQueue(aTrackId, inputBufferQueueProducer);
650     demuxer->isDump_ = true;
651     close(fd);
652 }
653 
FuzzTest27()654 void FuzzTest27()
655 {
656     int32_t fd = open(DATA_PATH, O_RDONLY);
657     struct stat statBuffer;
658     if (fstat(fd, &statBuffer) == -1) {
659         perror("Error getting file status");
660         close(fd);
661     }
662     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
663 
664     int32_t trackId = 0;
665     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
666     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
667     std::shared_ptr<AVBufferQueue> inputBufferQueue =
668         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
669     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
670     demuxer->SetOutputBufferQueue(trackId, inputBufferQueueProducer);
671     std::shared_ptr<Pipeline::EventReceiver> receiver = std::make_shared<TestEventReceiver>();
672     demuxer->SetEventReceiver(receiver);
673     demuxer->OnEvent({Plugins::PluginEventType::CLIENT_ERROR, "", "CLIENT_ERROR"});
674     demuxer->OnEvent({Plugins::PluginEventType::BUFFERING_END, "", "BUFFERING_END"});
675     demuxer->OnEvent({Plugins::PluginEventType::BUFFERING_START, "", "BUFFERING_START"});
676     demuxer->OnEvent({Plugins::PluginEventType::CACHED_DURATION, "", "CACHED_DURATION"});
677     demuxer->OnEvent({Plugins::PluginEventType::SOURCE_BITRATE_START, "", "SOURCE_BITRATE_START"});
678     demuxer->OnEvent({Plugins::PluginEventType::EVENT_BUFFER_PROGRESS, "", "EVENT_BUFFER_PROGRESS"});
679     demuxer->OnEvent({Plugins::PluginEventType::EVENT_CHANNEL_CLOSED, "", "EVENT_CHANNEL_CLOSED"});
680     close(fd);
681 }
682 
FuzzTest28()683 void FuzzTest28()
684 {
685     std::shared_ptr<DemuxerPluginManager> demuxerPluginManager = std::make_shared<DemuxerPluginManager>();
686     std::vector<StreamInfo> streams;
687     Plugins::StreamInfo info;
688     info.streamId = 0;
689     info.bitRate = 0;
690     info.type = Plugins::AUDIO;
691     streams.push_back(info);
692     streams.push_back(info);
693 
694     Plugins::StreamInfo info1;
695     info1.streamId = NUMBER_1;
696     info1.bitRate = 0;
697     info1.type = Plugins::VIDEO;
698     streams.push_back(info1);
699     streams.push_back(info1);
700 
701     Plugins::StreamInfo info2;
702     info2.streamId = NUMBER_2;
703     info2.bitRate = 0;
704     info2.type = Plugins::SUBTITLE;
705     streams.push_back(info2);
706     streams.push_back(info2);
707 
708     demuxerPluginManager->InitDefaultPlay(streams);
709     demuxerPluginManager->GetStreamCount();
710 
711     demuxerPluginManager->LoadDemuxerPlugin(-1, nullptr);
712     demuxerPluginManager->curSubTitleStreamID_  = -1;
713     Plugins::MediaInfo mediaInfo;
714     demuxerPluginManager->LoadCurrentSubtitlePlugin(nullptr, mediaInfo);
715     demuxerPluginManager->GetTmpInnerTrackIDByTrackID(-1);
716     demuxerPluginManager->GetInnerTrackIDByTrackID(-1);
717 
718     int32_t trackId = -1;
719     int32_t innerTrackId = -1;
720     demuxerPluginManager->GetTrackInfoByStreamID(0, trackId, innerTrackId);
721 
722     demuxerPluginManager->AddTrackMapInfo(0, 0);
723     demuxerPluginManager->AddTrackMapInfo(NUMBER_1, NUMBER_1);
724     demuxerPluginManager->AddTrackMapInfo(NUMBER_2, NUMBER_2);
725 
726     demuxerPluginManager->GetTrackInfoByStreamID(0, trackId, innerTrackId);
727     demuxerPluginManager->GetInnerTrackIDByTrackID(0);
728     demuxerPluginManager->CheckTrackIsActive(-1);
729 }
730 
FuzzTest29()731 void FuzzTest29()
732 {
733     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
734     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock = std::make_shared<DemuxerPluginMock>("StatusOK");
735     demuxer->audioTrackId_ = NUMBER_1;
736     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[0].streamID = 0;
737     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[NUMBER_1].streamID = NUMBER_1;
738     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[NUMBER_2].streamID = NUMBER_2;
739 
740     demuxer->demuxerPluginManager_->streamInfoMap_[0].plugin = pluginMock;
741     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_1].plugin = pluginMock;
742     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_2].plugin = pluginMock;
743 
744     demuxer->isParserTaskEnd_ = false;
745     uint32_t frameId = 0;
746     std::vector<uint32_t> IFramePos = { NUMBER_100 };
747 
748     demuxer->Dts2FrameId(NUMBER_100, frameId);
749     demuxer->GetIFramePos(IFramePos);
750 
751     demuxer->source_  = nullptr;
752     demuxer->Dts2FrameId(NUMBER_100, frameId);
753     demuxer->GetIFramePos(IFramePos);
754 
755     demuxer->demuxerPluginManager_  = nullptr;
756     demuxer->Dts2FrameId(NUMBER_100, frameId);
757     demuxer->GetIFramePos(IFramePos);
758 
759     demuxer->SetFrameRate(-1.0, 0);
760     demuxer->SetFrameRate(1.0, 0);
761 }
762 
FuzzTest30()763 void FuzzTest30()
764 {
765     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
766     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock = std::make_shared<DemuxerPluginMock>("StatusOK");
767     demuxer->audioTrackId_ = NUMBER_1;
768     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[0].streamID = 0;
769     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[NUMBER_1].streamID = NUMBER_1;
770     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[NUMBER_2].streamID = NUMBER_2;
771 
772     demuxer->demuxerPluginManager_->streamInfoMap_[0].plugin = pluginMock;
773     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_1].plugin = pluginMock;
774     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_2].plugin = pluginMock;
775 
776     demuxer->isParserTaskEnd_ = false;
777     uint32_t frameId = 0;
778     std::vector<uint32_t> IFramePos = { NUMBER_100 };
779 
780     demuxer->SeekMs2FrameId(NUMBER_100, frameId);
781     demuxer->GetIFramePos(IFramePos);
782 
783     demuxer->source_  = nullptr;
784     demuxer->SeekMs2FrameId(NUMBER_100, frameId);
785     demuxer->GetIFramePos(IFramePos);
786 
787     demuxer->demuxerPluginManager_  = nullptr;
788     demuxer->SeekMs2FrameId(NUMBER_100, frameId);
789     demuxer->GetIFramePos(IFramePos);
790 
791     demuxer->SetFrameRate(-1.0, 0);
792     demuxer->SetFrameRate(1.0, 0);
793 }
794 
FuzzTest31()795 void FuzzTest31()
796 {
797     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
798     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock = std::make_shared<DemuxerPluginMock>("StatusOK");
799     demuxer->audioTrackId_ = NUMBER_1;
800     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[0].streamID = 0;
801     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[NUMBER_1].streamID = NUMBER_1;
802     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[NUMBER_2].streamID = NUMBER_2;
803 
804     demuxer->demuxerPluginManager_->streamInfoMap_[0].plugin = pluginMock;
805     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_1].plugin = pluginMock;
806     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_2].plugin = pluginMock;
807 
808     demuxer->isParserTaskEnd_ = false;
809     int64_t seekMs = 0;
810     std::vector<uint32_t> IFramePos = { NUMBER_2 };
811 
812     demuxer->FrameId2SeekMs(NUMBER_100, seekMs);
813     demuxer->GetIFramePos(IFramePos);
814 
815     demuxer->source_  = nullptr;
816     demuxer->FrameId2SeekMs(NUMBER_100, seekMs);
817     demuxer->GetIFramePos(IFramePos);
818 
819     demuxer->demuxerPluginManager_  = nullptr;
820     demuxer->FrameId2SeekMs(NUMBER_100, seekMs);
821     demuxer->GetIFramePos(IFramePos);
822 
823     demuxer->SetFrameRate(-1.0, 0);
824     demuxer->SetFrameRate(1.0, 0);
825 }
826 
FuzzTest32()827 void FuzzTest32()
828 {
829     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
830     uint64_t relativePresentationTimeUs;
831     demuxer->GetRelativePresentationTimeUsByIndex(0, NUMBER_1, relativePresentationTimeUs);
832     uint32_t index;
833     demuxer->GetIndexByRelativePresentationTimeUs(0, NUMBER_1, index);
834 
835     demuxer->demuxerPluginManager_ = nullptr;
836     demuxer->GetRelativePresentationTimeUsByIndex(0, NUMBER_1, relativePresentationTimeUs);
837     demuxer->GetIndexByRelativePresentationTimeUs(0, NUMBER_1, index);
838 }
839 
FuzzTest33()840 void FuzzTest33()
841 {
842     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
843     std::shared_ptr<AVBuffer> sample = std::make_shared<AVBuffer>();
844     sample->pts_ = NUMBER_100;
845 
846     demuxer->audioTrackId_ = 0;
847     demuxer->shouldCheckAudioFramePts_ = false;
848     demuxer->CheckDropAudioFrame(sample, 0);
849     demuxer->lastAudioPts_ = NUMBER_100 + 1;
850     demuxer->CheckDropAudioFrame(sample, 0);
851     demuxer->shouldCheckAudioFramePts_ = true;
852     demuxer->CheckDropAudioFrame(sample, 0);
853     demuxer->lastAudioPts_ = NUMBER_100 - 1;
854     demuxer->CheckDropAudioFrame(sample, 0);
855 
856     demuxer->subtitleTrackId_ = 1;
857     demuxer->shouldCheckSubtitleFramePts_ = false;
858     demuxer->CheckDropAudioFrame(sample, 1);
859     demuxer->shouldCheckSubtitleFramePts_ = true;
860     demuxer->lastSubtitlePts_ = NUMBER_100 + 1;
861     demuxer->CheckDropAudioFrame(sample, 1);
862     demuxer->lastSubtitlePts_ = NUMBER_100 - 1;
863     demuxer->CheckDropAudioFrame(sample, 1);
864 
865     demuxer->CheckDropAudioFrame(sample, NUMBER_2);
866 
867     demuxer->videoTrackId_ = 1;
868     demuxer->isDecodeOptimizationEnabled_ = true;
869 
870     uint8_t* data = new uint8_t[NUMBER_100];
871     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(data, NUMBER_100, NUMBER_100);
872     demuxer->framerate_ = NUMBER_FRAMERATE_1;
873     demuxer->speed_ = 1.0;
874     demuxer->decoderFramerateUpperLimit_ = NUMBER_100;
875     demuxer->IsBufferDroppable(buffer, 1);
876 
877     demuxer->framerate_ = NUMBER_FRAMERATE_2;
878     demuxer->speed_ = 1.0;
879     demuxer->decoderFramerateUpperLimit_ = NUMBER_100;
880     demuxer->IsBufferDroppable(buffer, 1);
881 
882     buffer->meta_->SetData(Media::Tag::VIDEO_BUFFER_CAN_DROP, true);
883     demuxer->IsBufferDroppable(buffer, 1);
884 
885     delete[] data;
886 }
887 
FuzzTest34()888 void FuzzTest34()
889 {
890     int32_t fd = open(DATA_PATH, O_RDONLY);
891     struct stat statBuffer;
892     if (fstat(fd, &statBuffer) == -1) {
893         perror("Error getting file status");
894         close(fd);
895     }
896     std::string uri = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(statBuffer.st_size);
897 
898     int32_t aTrackId = 1;
899     int32_t vTrackId = 0;
900     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
901     demuxer->SetDataSource(std::make_shared<MediaSource>(uri));
902     std::shared_ptr<AVBufferQueue> inputBufferQueue =
903         AVBufferQueue::Create(NUMBER_8, MemoryType::SHARED_MEMORY, "testInputBufferQueue");
904     sptr<AVBufferQueueProducer> inputBufferQueueProducer = inputBufferQueue->GetProducer();
905     demuxer->SetOutputBufferQueue(aTrackId, inputBufferQueueProducer);
906 
907     demuxer->demuxerPluginManager_->isDash_ = true;
908     demuxer->SetDumpInfo(true, 0);
909     demuxer->isDecodeOptimizationEnabled_ = true;
910     std::shared_ptr<AVBuffer> aBuffer = AVBuffer::CreateAVBuffer();
911     std::shared_ptr<AVBuffer> vBuffer = AVBuffer::CreateAVBuffer();
912     demuxer->bufferMap_[aTrackId] = aBuffer;
913     demuxer->bufferMap_[vTrackId] = vBuffer;
914     vBuffer->meta_->SetData(Media::Tag::VIDEO_BUFFER_CAN_DROP, true);
915     close(fd);
916 }
917 
FuzzTest35()918 void FuzzTest35()
919 {
920     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
921     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
922     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock = std::make_shared<DemuxerPluginMock>("StatusErrorUnknown");
923     demuxer->audioTrackId_ = 1;
924     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[0].streamID = 0;
925     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[1].streamID = 1;
926     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[NUMBER_2].streamID = NUMBER_2;
927 
928     demuxer->demuxerPluginManager_->streamInfoMap_[0].plugin = pluginMock;
929     demuxer->demuxerPluginManager_->streamInfoMap_[1].plugin = pluginMock;
930     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_2].plugin = pluginMock;
931 
932     uint64_t relativePresentationTimeUs = 0;
933     demuxer->GetRelativePresentationTimeUsByIndex(0, 0, relativePresentationTimeUs);
934 }
935 
FuzzTest37()936 void FuzzTest37()
937 {
938     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
939     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
940     std::vector<uint8_t> val{0, 0};
941     std::multimap<std::string, std::vector<uint8_t>> info;
942     info.insert(std::pair<std::string, std::vector<uint8_t>>("key", val));
943     demuxer->localDrmInfos_ = info;
944     demuxer->HandleSourceDrmInfoEvent(info);
945 }
946 
FuzzTest38()947 void FuzzTest38()
948 {
949     std::shared_ptr<DemuxerPluginManager> demuxerManager = std::make_shared<DemuxerPluginManager>();
950     demuxerManager->curSubTitleStreamID_ = 0;
951     demuxerManager->AddExternalSubtitle();
952 
953     Meta metaTmp1;
954     metaTmp1.Set<Tag::MIME_TYPE>("audio/xxx");
955     demuxerManager->curMediaInfo_.tracks.push_back(metaTmp1);
956     Meta metaTmp2;
957     metaTmp2.Set<Tag::MIME_TYPE>("video/xxx");
958     demuxerManager->curMediaInfo_.tracks.push_back(metaTmp2);
959     Meta metaTmp3;
960     metaTmp3.Set<Tag::MIME_TYPE>("text/vtt");
961     demuxerManager->curMediaInfo_.tracks.push_back(metaTmp3);
962     Meta metaTmp4;
963     metaTmp4.Set<Tag::MIME_TYPE>("aaaa");
964     demuxerManager->curMediaInfo_.tracks.push_back(metaTmp4);
965     demuxerManager->GetTrackTypeByTrackID(0);
966     demuxerManager->GetTrackTypeByTrackID(1);
967     demuxerManager->GetTrackTypeByTrackID(NUMBER_2);
968     demuxerManager->GetTrackTypeByTrackID(NUMBER_3);
969 
970     demuxerManager->IsSubtitleMime("application/x-subrip");
971     demuxerManager->IsSubtitleMime("text/vtt");
972     demuxerManager->IsSubtitleMime("aaaaa");
973 }
974 
FuzzTest39()975 void FuzzTest39()
976 {
977     std::shared_ptr<DemuxerPluginManager> demuxerManager = std::make_shared<DemuxerPluginManager>();
978     Plugins::MediaInfo mediaInfo;
979     demuxerManager->UpdateDefaultStreamID(mediaInfo, AUDIO, 1);
980     demuxerManager->UpdateDefaultStreamID(mediaInfo, SUBTITLE, 1);
981     demuxerManager->UpdateDefaultStreamID(mediaInfo, VIDEO, 1);
982 }
983 
FuzzTest40()984 void FuzzTest40()
985 {
986     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock = std::make_shared<DemuxerPluginMock>("StatusErrorUnknown");
987     std::shared_ptr<DemuxerPluginManager> demuxerManager = std::make_shared<DemuxerPluginManager>();
988     demuxerManager->needResetEosStatus_ = true;
989 
990     MediaStreamInfo info1;
991     info1.plugin = pluginMock;
992     demuxerManager->streamInfoMap_[0] = info1;
993     MediaStreamInfo info2;
994     info2.plugin = pluginMock;
995     demuxerManager->streamInfoMap_[1] = info1;
996     MediaStreamInfo info3;
997     info3.plugin = pluginMock;
998     demuxerManager->streamInfoMap_[NUMBER_2] = info1;
999 
1000     demuxerManager->curVideoStreamID_ = 0;
1001     demuxerManager->curAudioStreamID_ = -1;
1002     demuxerManager->curSubTitleStreamID_ = -1;
1003     demuxerManager->Start();
1004     demuxerManager->Stop();
1005     demuxerManager->Reset();
1006     demuxerManager->Flush();
1007     int64_t realSeekTime;
1008     demuxerManager->SeekTo(1, Plugins::SeekMode::SEEK_PREVIOUS_SYNC, realSeekTime);
1009 }
1010 
FuzzTest41()1011 void FuzzTest41()
1012 {
1013     std::shared_ptr<DemuxerPluginManager> demuxerManager = std::make_shared<DemuxerPluginManager>();
1014     std::string pluginName = "avdemux_mov,mp4,m4a,3gp,3g2,mj2";
1015 
1016     MediaStreamInfo info;
1017     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock =
1018         std::make_shared<DemuxerPluginSetDataSourceFailMock<0>>("StatusOK");
1019     info.plugin = pluginMock;
1020     info.pluginName = pluginName;
1021     demuxerManager->streamInfoMap_[0] = info;
1022 
1023     std::shared_ptr<StreamDemuxer> streamDemuxer = std::make_shared<StreamDemuxerMock>();
1024     std::thread initPluginThread([demuxerManager, streamDemuxer, pluginName]() {
1025         demuxerManager->InitPlugin(streamDemuxer, pluginName, 0);
1026     });
1027     initPluginThread.join();
1028 }
1029 
FuzzTest45()1030 void FuzzTest45()
1031 {
1032     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1033 
1034     demuxer->source_->seekToTimeFlag_ = true;
1035     demuxer->videoTrackId_  = 0;
1036     demuxer->demuxerPluginManager_->isDash_ = false;
1037 
1038     std::shared_ptr<AVBuffer> sample = std::make_shared<AVBuffer>();
1039     sample->pts_ = NUMBER_100;
1040     demuxer->DoSelectTrack(0, MediaDemuxer::TRACK_ID_INVALID);
1041 }
1042 
FuzzTest46()1043 void FuzzTest46()
1044 {
1045     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1046     demuxer->HandleDashSelectTrack(0);
1047 
1048     Meta metaTmp1;
1049     metaTmp1.Set<Tag::MIME_TYPE>("audio/xxx");
1050     demuxer->demuxerPluginManager_->curMediaInfo_.tracks.push_back(metaTmp1);
1051     Meta metaTmp2;
1052     metaTmp2.Set<Tag::MIME_TYPE>("video/xxx");
1053     demuxer->demuxerPluginManager_->curMediaInfo_.tracks.push_back(metaTmp2);
1054     Meta metaTmp3;
1055     metaTmp3.Set<Tag::MIME_TYPE>("text/vtt");
1056     demuxer->demuxerPluginManager_->curMediaInfo_.tracks.push_back(metaTmp3);
1057     Meta metaTmp4;
1058     metaTmp4.Set<Tag::MIME_TYPE>("aaaaa");
1059     demuxer->demuxerPluginManager_->curMediaInfo_.tracks.push_back(metaTmp4);
1060 
1061     demuxer->demuxerPluginManager_->AddTrackMapInfo(0, 0);
1062     demuxer->demuxerPluginManager_->AddTrackMapInfo(1, 0);
1063     demuxer->demuxerPluginManager_->AddTrackMapInfo(NUMBER_2, 0);
1064     demuxer->demuxerPluginManager_->AddTrackMapInfo(NUMBER_3, 0);
1065 
1066     demuxer->audioTrackId_ = 0;
1067     demuxer->videoTrackId_ = 1;
1068     demuxer->subtitleTrackId_ = NUMBER_2;
1069 
1070     demuxer->HandleDashSelectTrack(0);
1071     demuxer->HandleDashSelectTrack(1);
1072     demuxer->HandleDashSelectTrack(NUMBER_2);
1073     demuxer->HandleDashSelectTrack(NUMBER_3);
1074 }
1075 
FuzzTest47()1076 void FuzzTest47()
1077 {
1078     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1079     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
1080     demuxer->audioTrackId_ = 0;
1081     demuxer->videoTrackId_ = 0;
1082     demuxer->subtitleTrackId_ = 0;
1083 
1084     demuxer->demuxerPluginManager_->isDash_ = false;
1085     demuxer->SeekToTimeAfter();
1086     demuxer->demuxerPluginManager_->isDash_ = true;
1087     demuxer->isSelectBitRate_ = true;
1088     demuxer->SeekToTimeAfter();
1089 }
1090 
FuzzTest48()1091 void FuzzTest48()
1092 {
1093     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1094     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
1095     std::shared_ptr<AVBuffer> sample = std::make_shared<AVBuffer>();
1096     sample->pts_ = NUMBER_100;
1097     demuxer->audioTrackId_ = 0;
1098     demuxer->subtitleTrackId_ = NUMBER_2;
1099     demuxer->shouldCheckAudioFramePts_  = true;
1100     demuxer->lastAudioPts_  = NUMBER_200;
1101     demuxer->CheckDropAudioFrame(sample, 0);
1102 
1103     demuxer->shouldCheckAudioFramePts_  = false;
1104     demuxer->CheckDropAudioFrame(sample, NUMBER_2);
1105     demuxer->lastSubtitlePts_  = NUMBER_200;
1106     demuxer->shouldCheckAudioFramePts_  = true;
1107     demuxer->CheckDropAudioFrame(sample, NUMBER_2);
1108 
1109     demuxer->IsVideoEos();
1110     demuxer->videoTrackId_ = 0;
1111     demuxer->eosMap_[0] = true;
1112     demuxer->IsVideoEos();
1113 
1114     demuxer->IsRenderNextVideoFrameSupported();
1115     demuxer->ResumeDragging();
1116 }
1117 
FuzzTest49()1118 void FuzzTest49()
1119 {
1120     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1121     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
1122     demuxer->streamDemuxer_->SetNewAudioStreamID(0);
1123     demuxer->streamDemuxer_->SetNewVideoStreamID(1);
1124     demuxer->streamDemuxer_->SetNewSubtitleStreamID(NUMBER_2);
1125     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock = std::make_shared<DemuxerPluginMock>("StatusErrorUnknown");
1126 
1127     demuxer->audioTrackId_ = 0;
1128     demuxer->videoTrackId_ = 1;
1129     demuxer->subtitleTrackId_ = NUMBER_2;
1130 
1131     Meta metaTmp1;
1132     metaTmp1.Set<Tag::MIME_TYPE>("audio/xxx");
1133     demuxer->demuxerPluginManager_->curMediaInfo_.tracks.push_back(metaTmp1);
1134     Meta metaTmp2;
1135     metaTmp2.Set<Tag::MIME_TYPE>("video/xxx");
1136     demuxer->demuxerPluginManager_->curMediaInfo_.tracks.push_back(metaTmp2);
1137     Meta metaTmp3;
1138     metaTmp3.Set<Tag::MIME_TYPE>("text/vtt");
1139     demuxer->demuxerPluginManager_->curMediaInfo_.tracks.push_back(metaTmp3);
1140     Meta metaTmp4;
1141     metaTmp4.Set<Tag::MIME_TYPE>("aaaa");
1142     demuxer->demuxerPluginManager_->curMediaInfo_.tracks.push_back(metaTmp4);
1143     demuxer->SelectTrackChangeStream(NUMBER_5);
1144 
1145     demuxer->demuxerPluginManager_->AddTrackMapInfo(0, 0);
1146     demuxer->demuxerPluginManager_->AddTrackMapInfo(1, 0);
1147     demuxer->demuxerPluginManager_->AddTrackMapInfo(NUMBER_2, 0);
1148 
1149     MediaStreamInfo info1;
1150     info1.plugin = pluginMock;
1151     info1.streamID = 0;
1152     info1.type = StreamType::AUDIO;
1153     demuxer->demuxerPluginManager_->streamInfoMap_[0] = info1;
1154     MediaStreamInfo info2;
1155     info2.plugin = pluginMock;
1156     info2.streamID = 1;
1157     info2.type = StreamType::VIDEO;
1158     demuxer->demuxerPluginManager_->streamInfoMap_[1] = info2;
1159     MediaStreamInfo info3;
1160     info3.plugin = pluginMock;
1161     info3.streamID = NUMBER_2;
1162     info3.type = StreamType::SUBTITLE;
1163     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_2] = info3;
1164 
1165     demuxer->SelectTrackChangeStream(0);
1166 }
1167 
FuzzTest50()1168 void FuzzTest50()
1169 {
1170     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1171     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
1172     demuxer->source_->plugin_ = std::make_shared<SourcePluginMock>("StatusOK");
1173     demuxer->demuxerPluginManager_->isDash_ = true;
1174     demuxer->streamDemuxer_->changeStreamFlag_ = false;
1175     demuxer->SelectBitRate(1);
1176 
1177     std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
1178     demuxer->mediaMetaData_.trackMetas.push_back(meta1);
1179     demuxer->mediaMetaData_.trackMetas.push_back(meta1);
1180     demuxer->mediaMetaData_.trackMetas.push_back(meta1);
1181     demuxer->mediaMetaData_.trackMetas.push_back(meta1);
1182     demuxer->mediaMetaData_.trackMetas.push_back(meta1);
1183 
1184     demuxer->videoTrackId_ = NUMBER_2;
1185     demuxer->useBufferQueue_ = true;
1186     demuxer->SelectBitRate(NUMBER_3);
1187 
1188     std::vector<uint32_t> bitRates;
1189     demuxer->GetBitRates(bitRates);
1190 
1191     demuxer->source_ = nullptr;
1192     int64_t durationMs;
1193     demuxer->GetDuration(durationMs);
1194 }
1195 
FuzzTest51()1196 void FuzzTest51()
1197 {
1198     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1199     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
1200     demuxer->videoTrackId_ = 1;
1201     demuxer->StartReferenceParser(1, false);
1202     demuxer->demuxerPluginManager_ = nullptr;
1203     demuxer->StartReferenceParser(1, false);
1204     demuxer->videoTrackId_ = MediaDemuxer::TRACK_ID_INVALID;
1205     demuxer->StartReferenceParser(1, false);
1206     demuxer->source_ = nullptr;
1207     demuxer->StartReferenceParser(1, false);
1208     demuxer->StartReferenceParser(-1, false);
1209 }
1210 
FuzzTest52()1211 void FuzzTest52()
1212 {
1213     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1214     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
1215     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock = std::make_shared<DemuxerPluginMock>("StatusErrorUnknown");
1216     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock1 = std::make_shared<DemuxerPluginMock>("StatusOK");
1217     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[0].streamID = 0;
1218     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[1].streamID = 1;
1219     demuxer->demuxerPluginManager_->temp2TrackInfoMap_[NUMBER_2].streamID = NUMBER_2;
1220 
1221     demuxer->demuxerPluginManager_->streamInfoMap_[0].plugin = nullptr;
1222     demuxer->demuxerPluginManager_->streamInfoMap_[1].plugin = pluginMock;
1223     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_2].plugin = pluginMock1;
1224 
1225     demuxer->videoTrackId_ = 0;
1226     demuxer->StartReferenceParser(1, false);
1227 
1228     demuxer->videoTrackId_ = 1;
1229     demuxer->StartReferenceParser(1, false);
1230 
1231     demuxer->videoTrackId_ = NUMBER_2;
1232     demuxer->isFirstParser_ = true;
1233     demuxer->StartReferenceParser(1, false);
1234 }
1235 
FuzzTest53()1236 void FuzzTest53()
1237 {
1238     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1239     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
1240 
1241     FrameLayerInfo frameLayerInfo;
1242     demuxer->GetFrameLayerInfo(nullptr, frameLayerInfo);
1243     std::shared_ptr<AVBuffer> sample = std::make_shared<AVBuffer>();
1244     demuxer->demuxerPluginManager_  = nullptr;
1245     demuxer->GetFrameLayerInfo(sample, frameLayerInfo);
1246     demuxer->source_ = nullptr;
1247     demuxer->GetFrameLayerInfo(sample, frameLayerInfo);
1248 }
1249 
FuzzTest54()1250 void FuzzTest54()
1251 {
1252     std::shared_ptr<MediaDemuxer> demuxer = std::make_shared<MediaDemuxer>();
1253     demuxer->streamDemuxer_ = std::make_shared<StreamDemuxer>();
1254     std::shared_ptr<Plugins::DemuxerPlugin> pluginMock1 = std::make_shared<DemuxerPluginMock>("StatusOK");
1255 
1256     demuxer->demuxerPluginManager_->curVideoStreamID_ = 0;
1257     demuxer->demuxerPluginManager_->curAudioStreamID_ = 1;
1258     demuxer->demuxerPluginManager_->curSubTitleStreamID_ = NUMBER_2;
1259     demuxer->demuxerPluginManager_->streamInfoMap_[0].plugin = pluginMock1;
1260     demuxer->demuxerPluginManager_->streamInfoMap_[0].type = StreamType::VIDEO;
1261     demuxer->demuxerPluginManager_->streamInfoMap_[1].plugin = pluginMock1;
1262     demuxer->demuxerPluginManager_->streamInfoMap_[1].type = StreamType::AUDIO;
1263     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_2].plugin = pluginMock1;
1264     demuxer->demuxerPluginManager_->streamInfoMap_[NUMBER_2].type = StreamType::SUBTITLE;
1265 
1266     demuxer->SetCacheLimit(NUMBER_10);
1267 
1268     demuxer->demuxerPluginManager_->AddTrackMapInfo(0, 0);
1269     demuxer->demuxerPluginManager_->AddTrackMapInfo(1, 0);
1270     demuxer->demuxerPluginManager_->AddTrackMapInfo(NUMBER_2, 0);
1271     demuxer->demuxerPluginManager_->GetStreamTypeByTrackID(0);
1272 }
1273 }
1274 }
1275 
1276 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(uint8_t * data,size_t size)1277 extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size)
1278 {
1279     OHOS::Media::RunMediaDemuxerFuzz(data, size);
1280     return 0;
1281 }
1282 
1283