1 /*
2  * Copyright (C) 2023 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 <malloc.h>
18 #include <sys/stat.h>
19 #include <cinttypes>
20 #include <fcntl.h>
21 #include <list>
22 #include <map>
23 #include <cmath>
24 #include "gtest/gtest.h"
25 #include "avcodec_errors.h"
26 #include "media_description.h"
27 #include "file_server_demo.h"
28 #include "demuxer_unit_test.h"
29 
30 #define LOCAL true
31 #define URI false
32 
33 using namespace OHOS;
34 using namespace OHOS::Media;
35 using namespace OHOS::MediaAVCodec;
36 using namespace testing::ext;
37 using namespace std;
38 
39 namespace {
40 unique_ptr<FileServerDemo> server = nullptr;
41 static const string TEST_FILE_PATH = "/data/test/media/";
42 static const string TEST_URI_PATH = "http://127.0.0.1:46666/";
43 static const string TEST_URI_PATH2 = "http://192.168.3.11:8080/share/";
44 
45 const std::string HEVC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_hevc_parser.z.so";
46 const int64_t SOURCE_OFFSET = 0;
47 list<SeekMode> seekModes = {SeekMode::SEEK_NEXT_SYNC, SeekMode::SEEK_PREVIOUS_SYNC,
48     SeekMode::SEEK_CLOSEST_SYNC};
49 
50 string g_hdrVividPath = TEST_FILE_PATH + string("hdrvivid_720p_2s.mp4");
51 string g_hdrVividUri = TEST_URI_PATH + string("hdrvivid_720p_2s.mp4");
52 string g_mp4HevcPath = TEST_FILE_PATH + string("camera_h265_aac_rotate270.mp4");
53 string g_mp4HevcUri = TEST_URI_PATH + string("camera_h265_aac_rotate270.mp4");
54 string g_mkvHevcAccPath = TEST_FILE_PATH + string("h265_aac_4sec.mkv");
55 string g_mkvHevcAccUri = TEST_URI_PATH + string("h265_aac_4sec.mkv");
56 string g_mkvAvcOpusPath = TEST_FILE_PATH + string("h264_opus_4sec.mkv");
57 string g_mkvAvcOpusUri = TEST_URI_PATH + string("h264_opus_4sec.mkv");
58 string g_mkvAvcMp3Path = TEST_FILE_PATH + string("h264_mp3_4sec.mkv");
59 string g_mkvAvcMp3Uri = TEST_URI_PATH + string("h264_mp3_4sec.mkv");
60 string g_tsHevcAacPath = TEST_FILE_PATH + string("hevc_aac_1920x1080_g30_30fps.ts");
61 string g_tsHevcAacUri = TEST_URI_PATH + string("hevc_aac_1920x1080_g30_30fps.ts");
62 string g_tsHevcAac4KPath = TEST_FILE_PATH + string("hevc_aac_3840x2160_30frames.ts");
63 string g_flvPath = TEST_FILE_PATH + string("h265_enhanced.flv");
64 string g_flvUri = TEST_URI_PATH + string("h265_enhanced.flv");
65 string g_fmp4HevcPath = TEST_FILE_PATH + string("h265_fmp4.mp4");
66 string g_fmp4HevcUri = TEST_URI_PATH + string("h265_fmp4.mp4");
67 string g_doubleVividPath = TEST_FILE_PATH + string("audiovivid_hdrvivid_2s.mp4");
68 string g_doubleVividUri = TEST_URI_PATH + string("audiovivid_hdrvivid_2s.mp4");
69 string g_hls = TEST_URI_PATH2 + string("index_265.m3u8");
70 string g_mp4265InfoParsePath = TEST_FILE_PATH + string("test_265_B_Gop25_4sec.mp4");
71 
72 std::map<std::string, std::map<std::string, std::vector<int32_t>>> infoMap = {
73     {"hdrVivid",   {{"frames", {76,   125}}, {"kFrames", {3, 125}}}},
74     {"mp4Hevc",    {{"frames", {60,   87 }}, {"kFrames", {1, 87 }}}},
75     {"mkvHevcAcc", {{"frames", {242,  173}}, {"kFrames", {1, 173}}}},
76     {"mkvAvcOpus", {{"frames", {240,  199}}, {"kFrames", {4, 199}}}},
77     {"mkvAvcMp3",  {{"frames", {239,  153}}, {"kFrames", {4, 153}}}},
78     {"tsHevcAac",  {{"frames", {303,  433}}, {"kFrames", {11, 433}}}},
79     {"fmp4Hevc",  {{"frames", {604,  433}}, {"kFrames", {3, 433}}}},
80     {"doubleVivid",  {{"frames", {76,  116}}, {"kFrames", {3, 116}}}},
81     {"mp4265InfoParse",  {{"frames", {103,  174}}, {"kFrames", {5, 174}}}},
82 };
83 
84 std::map<std::string, std::vector<int32_t>> discardFrameIndexMap = {
85     {g_mp4265InfoParsePath, {-1, 1}}
86 };
87 } // namespace
88 
InitResource(const std::string &path, bool local)89 void DemuxerUnitTest::InitResource(const std::string &path, bool local)
90 {
91     printf("---- %s ------\n", path.c_str());
92     if (local) {
93         fd_ = OpenFile(path);
94         int64_t size = GetFileSize(path);
95         source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size);
96         ASSERT_NE(source_, nullptr);
97     } else {
98         source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(path.data()));
99         ASSERT_NE(source_, nullptr);
100     }
101     format_ = source_->GetSourceFormat();
102     ASSERT_NE(format_, nullptr);
103     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, nbStreams_));
104     demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_);
105     ASSERT_NE(demuxer_, nullptr);
106     initStatus_ = true;
107 }
108 
ReadSample(const std::string &path, bool local, bool checkBufferInfo)109 void DemuxerUnitTest::ReadSample(const std::string &path, bool local, bool checkBufferInfo)
110 {
111     InitResource(path, local);
112     ASSERT_TRUE(initStatus_);
113     SetInitValue();
114     for (auto idx : selectedTrackIds_) {
115         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
116     }
117     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
118     ASSERT_NE(sharedMem_, nullptr);
119 
120     while (!isEOS(eosFlag_)) {
121         for (auto idx : selectedTrackIds_) {
122             ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_, checkBufferInfo), AV_ERR_OK);
123             CountFrames(idx);
124             if (checkBufferInfo && discardFrameIndexMap.count(path) != 0 &&
125                 flag_ & static_cast<uint32_t>(AVBufferFlag::DISCARD)) {
126                 printf("[track %d] frame %d flag is discard\n", idx, frames_[idx]);
127                 ASSERT_EQ(discardFrameIndexMap[path][idx], frames_[idx]);
128             }
129         }
130     }
131 }
132 
133 namespace {
134 /**
135  * @tc.name: Demuxer_ReadSample_1220
136  * @tc.desc: copy current sample to buffer, local
137  * @tc.type: FUNC
138  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1220, TestSize.Level1)139 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1220, TestSize.Level1)
140 {
141     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
142         return;
143     }
144     ReadSample(g_hdrVividPath, LOCAL);
145     for (auto idx : selectedTrackIds_) {
146         ASSERT_EQ(frames_[idx], infoMap["hdrVivid"]["frames"][idx]);
147         ASSERT_EQ(keyFrames_[idx], infoMap["hdrVivid"]["kFrames"][idx]);
148     }
149     RemoveValue();
150     selectedTrackIds_.clear();
151 }
152 
153 /**
154  * @tc.name: Demuxer_ReadSample_1221
155  * @tc.desc: copy current sample to buffer, uri
156  * @tc.type: FUNC
157  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1221, TestSize.Level1)158 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1221, TestSize.Level1)
159 {
160     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
161         return;
162     }
163     ReadSample(g_hdrVividUri, URI);
164     for (auto idx : selectedTrackIds_) {
165         ASSERT_EQ(frames_[idx], infoMap["hdrVivid"]["frames"][idx]);
166         ASSERT_EQ(keyFrames_[idx], infoMap["hdrVivid"]["kFrames"][idx]);
167     }
168     RemoveValue();
169     selectedTrackIds_.clear();
170 }
171 
172 /**
173  * @tc.name: Demuxer_ReadSample_1200
174  * @tc.desc: copy current sample to buffer, local
175  * @tc.type: FUNC
176  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1200, TestSize.Level1)177 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1200, TestSize.Level1)
178 {
179     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
180         return;
181     }
182     ReadSample(g_mp4HevcPath, LOCAL);
183     for (auto idx : selectedTrackIds_) {
184         ASSERT_EQ(frames_[idx], infoMap["mp4Hevc"]["frames"][idx]);
185         ASSERT_EQ(keyFrames_[idx], infoMap["mp4Hevc"]["kFrames"][idx]);
186     }
187     RemoveValue();
188     selectedTrackIds_.clear();
189 }
190 
191 /**
192  * @tc.name: Demuxer_ReadSample_1201
193  * @tc.desc: copy current sample to buffer, uri
194  * @tc.type: FUNC
195  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1201, TestSize.Level1)196 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1201, TestSize.Level1)
197 {
198     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
199         return;
200     }
201     ReadSample(g_mp4HevcUri, URI);
202     for (auto idx : selectedTrackIds_) {
203         ASSERT_EQ(frames_[idx], infoMap["mp4Hevc"]["frames"][idx]);
204         ASSERT_EQ(keyFrames_[idx], infoMap["mp4Hevc"]["kFrames"][idx]);
205     }
206     RemoveValue();
207     selectedTrackIds_.clear();
208 }
209 
210 /**
211  * @tc.name: Demuxer_ReadSample_1210
212  * @tc.desc: copy current sample to buffer, local
213  * @tc.type: FUNC
214  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1210, TestSize.Level1)215 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1210, TestSize.Level1)
216 {
217     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
218         return;
219     }
220     ReadSample(g_mkvHevcAccPath, LOCAL);
221     for (auto idx : selectedTrackIds_) {
222         ASSERT_EQ(frames_[idx], infoMap["mkvHevcAcc"]["frames"][idx]);
223         ASSERT_EQ(keyFrames_[idx], infoMap["mkvHevcAcc"]["kFrames"][idx]);
224     }
225     RemoveValue();
226     selectedTrackIds_.clear();
227 }
228 
229 /**
230  * @tc.name: Demuxer_ReadSample_1211
231  * @tc.desc: copy current sample to buffer, local
232  * @tc.type: FUNC
233  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1211, TestSize.Level1)234 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1211, TestSize.Level1)
235 {
236     ReadSample(g_mkvAvcOpusPath, LOCAL);
237     for (auto idx : selectedTrackIds_) {
238         ASSERT_EQ(frames_[idx], infoMap["mkvAvcOpus"]["frames"][idx]);
239         ASSERT_EQ(keyFrames_[idx], infoMap["mkvAvcOpus"]["kFrames"][idx]);
240     }
241     RemoveValue();
242     selectedTrackIds_.clear();
243 }
244 
245 /**
246  * @tc.name: Demuxer_ReadSample_1212
247  * @tc.desc: copy current sample to buffer, local
248  * @tc.type: FUNC
249  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1212, TestSize.Level1)250 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1212, TestSize.Level1)
251 {
252     ReadSample(g_mkvAvcMp3Path, LOCAL);
253     for (auto idx : selectedTrackIds_) {
254         ASSERT_EQ(frames_[idx], infoMap["mkvAvcMp3"]["frames"][idx]);
255         ASSERT_EQ(keyFrames_[idx], infoMap["mkvAvcMp3"]["kFrames"][idx]);
256     }
257     RemoveValue();
258     selectedTrackIds_.clear();
259 }
260 
261 /**
262  * @tc.name: Demuxer_ReadSample_1213
263  * @tc.desc: copy current sample to buffer, uri
264  * @tc.type: FUNC
265  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1213, TestSize.Level1)266 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1213, TestSize.Level1)
267 {
268     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
269         return;
270     }
271     ReadSample(g_mkvHevcAccUri, URI);
272     for (auto idx : selectedTrackIds_) {
273         ASSERT_EQ(frames_[idx], infoMap["mkvHevcAcc"]["frames"][idx]);
274         ASSERT_EQ(keyFrames_[idx], infoMap["mkvHevcAcc"]["kFrames"][idx]);
275     }
276     RemoveValue();
277     selectedTrackIds_.clear();
278 }
279 
280 /**
281  * @tc.name: Demuxer_ReadSample_1214
282  * @tc.desc: copy current sample to buffer, uri
283  * @tc.type: FUNC
284  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1214, TestSize.Level1)285 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1214, TestSize.Level1)
286 {
287     ReadSample(g_mkvAvcOpusUri, URI);
288     for (auto idx : selectedTrackIds_) {
289         ASSERT_EQ(frames_[idx], infoMap["mkvAvcOpus"]["frames"][idx]);
290         ASSERT_EQ(keyFrames_[idx], infoMap["mkvAvcOpus"]["kFrames"][idx]);
291     }
292     RemoveValue();
293     selectedTrackIds_.clear();
294 }
295 
296 /**
297  * @tc.name: Demuxer_ReadSample_1215
298  * @tc.desc: copy current sample to buffer, uri
299  * @tc.type: FUNC
300  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1215, TestSize.Level1)301 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1215, TestSize.Level1)
302 {
303     ReadSample(g_mkvAvcMp3Uri, URI);
304     for (auto idx : selectedTrackIds_) {
305         ASSERT_EQ(frames_[idx], infoMap["mkvAvcMp3"]["frames"][idx]);
306         ASSERT_EQ(keyFrames_[idx], infoMap["mkvAvcMp3"]["kFrames"][idx]);
307     }
308     RemoveValue();
309     selectedTrackIds_.clear();
310 }
311 
312 /**
313  * @tc.name: Demuxer_ReadSample_1216
314  * @tc.desc: copy current sample to buffer, local(ts)
315  * @tc.type: FUNC
316  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1216, TestSize.Level1)317 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1216, TestSize.Level1)
318 {
319     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
320         return;
321     }
322     ReadSample(g_tsHevcAacPath, LOCAL);
323     for (auto idx : selectedTrackIds_) {
324         ASSERT_EQ(frames_[idx], infoMap["tsHevcAac"]["frames"][idx]);
325         ASSERT_EQ(keyFrames_[idx], infoMap["tsHevcAac"]["kFrames"][idx]);
326     }
327     RemoveValue();
328     selectedTrackIds_.clear();
329 }
330 
331 /**
332  * @tc.name: Demuxer_ReadSample_1217
333  * @tc.desc: copy current sample to buffer, uri(ts)
334  * @tc.type: FUNC
335  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1217, TestSize.Level1)336 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1217, TestSize.Level1)
337 {
338     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
339         return;
340     }
341     ReadSample(g_tsHevcAacPath, URI);
342     for (auto idx : selectedTrackIds_) {
343         ASSERT_EQ(frames_[idx], infoMap["tsHevcAac"]["frames"][idx]);
344         ASSERT_EQ(keyFrames_[idx], infoMap["tsHevcAac"]["kFrames"][idx]);
345     }
346     RemoveValue();
347     selectedTrackIds_.clear();
348 }
349 
350 /**
351  * @tc.name: Demuxer_ReadSample_1218
352  * @tc.desc: copy current sample to buffer, local(ts)
353  * @tc.type: FUNC
354  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1218, TestSize.Level1)355 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1218, TestSize.Level1)
356 {
357     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
358         return;
359     }
360     string path = TEST_FILE_PATH + string("hevc_aac_3840x2160_30frames.ts");
361     ReadSample(path, LOCAL);
362     for (auto idx : selectedTrackIds_) {
363         ASSERT_EQ(frames_[idx], 30);
364         ASSERT_EQ(keyFrames_[idx], 1);
365     }
366     RemoveValue();
367     selectedTrackIds_.clear();
368 }
369 
370 /**
371  * @tc.name: Demuxer_ReadSample_1226
372  * @tc.desc: copy current sample to buffer, local
373  * @tc.type: FUNC
374  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1226, TestSize.Level1)375 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1226, TestSize.Level1)
376 {
377     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
378         return;
379     }
380     ReadSample(g_fmp4HevcPath, LOCAL);
381     for (auto idx : selectedTrackIds_) {
382         ASSERT_EQ(frames_[idx], infoMap["fmp4Hevc"]["frames"][idx]);
383         ASSERT_EQ(keyFrames_[idx], infoMap["fmp4Hevc"]["kFrames"][idx]);
384     }
385     RemoveValue();
386     selectedTrackIds_.clear();
387 }
388 
389 /**
390  * @tc.name: Demuxer_ReadSample_1227
391  * @tc.desc: copy current sample to buffer, uri
392  * @tc.type: FUNC
393  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1227, TestSize.Level1)394 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1227, TestSize.Level1)
395 {
396     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
397         return;
398     }
399     ReadSample(g_fmp4HevcUri, URI);
400     for (auto idx : selectedTrackIds_) {
401         ASSERT_EQ(frames_[idx], infoMap["fmp4Hevc"]["frames"][idx]);
402         ASSERT_EQ(keyFrames_[idx], infoMap["fmp4Hevc"]["kFrames"][idx]);
403     }
404     RemoveValue();
405     selectedTrackIds_.clear();
406 }
407 
408 /**
409  * @tc.name: Demuxer_ReadSample_1231
410  * @tc.desc: copy current sample to buffer, local
411  * @tc.type: FUNC
412  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1231, TestSize.Level1)413 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1231, TestSize.Level1)
414 {
415     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
416         return;
417     }
418     ReadSample(g_doubleVividPath, LOCAL);
419     for (auto idx : selectedTrackIds_) {
420         ASSERT_EQ(frames_[idx], infoMap["doubleVivid"]["frames"][idx]);
421         ASSERT_EQ(keyFrames_[idx], infoMap["doubleVivid"]["kFrames"][idx]);
422     }
423     RemoveValue();
424     selectedTrackIds_.clear();
425 }
426 
427 /**
428  * @tc.name: Demuxer_ReadSample_1232
429  * @tc.desc: copy current sample to buffer, uri
430  * @tc.type: FUNC
431  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1232, TestSize.Level1)432 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1232, TestSize.Level1)
433 {
434     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
435         return;
436     }
437     ReadSample(g_doubleVividUri, URI);
438     for (auto idx : selectedTrackIds_) {
439         ASSERT_EQ(frames_[idx], infoMap["doubleVivid"]["frames"][idx]);
440         ASSERT_EQ(keyFrames_[idx], infoMap["doubleVivid"]["kFrames"][idx]);
441     }
442     RemoveValue();
443     selectedTrackIds_.clear();
444 }
445 
446 /**
447  * @tc.name: Demuxer_SeekToTime_1170
448  * @tc.desc: seek to the specified time(h265 mp4 fd)
449  * @tc.type: FUNC
450  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1170, TestSize.Level1)451 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1170, TestSize.Level1)
452 {
453     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
454         return;
455     }
456     InitResource(g_mp4HevcPath, LOCAL);
457     ASSERT_TRUE(initStatus_);
458     SetInitValue();
459     for (auto idx : selectedTrackIds_) {
460         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
461     }
462     list<int64_t> toPtsList = {0, 1500, 1000, 1740, 1970, 2100}; // ms
463     vector<int32_t> videoVals = {60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60};
464     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
465     ASSERT_NE(sharedMem_, nullptr);
466     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
467         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
468             ret_ = demuxer_->SeekToTime(*toPts, *mode);
469             if (ret_ != AV_ERR_OK) {
470                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
471                 continue;
472             }
473             ReadData();
474             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
475             ASSERT_EQ(frames_[0], videoVals[numbers_]);
476             numbers_ += 1;
477             RemoveValue();
478             selectedTrackIds_.clear();
479         }
480     }
481 }
482 
483 /**
484  * @tc.name: Demuxer_SeekToTime_1171
485  * @tc.desc: seek to the specified time(h265 mp4 uri)
486  * @tc.type: FUNC
487  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1171, TestSize.Level1)488 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1171, TestSize.Level1)
489 {
490     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
491         return;
492     }
493     InitResource(g_mp4HevcUri, URI);
494     ASSERT_TRUE(initStatus_);
495     SetInitValue();
496     for (auto idx : selectedTrackIds_) {
497         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
498     }
499     list<int64_t> toPtsList = {0, 1500, 1000, 1740, 1970, 2100}; // ms
500     vector<int32_t> videoVals = {60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60};
501     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
502     ASSERT_NE(sharedMem_, nullptr);
503     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
504         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
505             ret_ = demuxer_->SeekToTime(*toPts, *mode);
506             if (ret_ != AV_ERR_OK) {
507                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
508                 continue;
509             }
510             ReadData();
511             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
512             ASSERT_EQ(frames_[0], videoVals[numbers_]);
513             numbers_ += 1;
514             RemoveValue();
515             selectedTrackIds_.clear();
516         }
517     }
518 }
519 
520 /**
521  * @tc.name: Demuxer_SeekToTime_1180
522  * @tc.desc: seek to the specified time(h265+aac(mkv) fd)
523  * @tc.type: FUNC
524  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1180, TestSize.Level1)525 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1180, TestSize.Level1)
526 {
527     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
528         return;
529     }
530     InitResource(g_mkvHevcAccPath, LOCAL);
531     ASSERT_TRUE(initStatus_);
532     SetInitValue();
533     for (auto idx : selectedTrackIds_) {
534         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
535     }
536     list<int64_t> toPtsList = {0, 1000, 2000, 1500, 2160, 3630, 2850, 4017, 4300}; // ms
537     vector<int32_t> videoVals = {242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
538         242, 242, 242, 242, 242, 242, 242, 242, 242};
539     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
540     ASSERT_NE(sharedMem_, nullptr);
541     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
542         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
543             ret_ = demuxer_->SeekToTime(*toPts, *mode);
544             if (ret_ != AV_ERR_OK) {
545                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
546                 continue;
547             }
548             ReadData();
549             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
550             ASSERT_EQ(frames_[0], videoVals[numbers_]);
551             numbers_ += 1;
552             RemoveValue();
553             selectedTrackIds_.clear();
554         }
555     }
556 }
557 
558 /**
559  * @tc.name: Demuxer_SeekToTime_1181
560  * @tc.desc: seek to the specified time(h264+opus(mkv) fd)
561  * @tc.type: FUNC
562  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1181, TestSize.Level1)563 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1181, TestSize.Level1)
564 {
565     InitResource(g_mkvAvcOpusPath, LOCAL);
566     ASSERT_TRUE(initStatus_);
567     SetInitValue();
568     for (auto idx : selectedTrackIds_) {
569         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
570     }
571     list<int64_t> toPtsList = {0, 2000, 1500, 1720, 2700, 3980, 4000, 4100}; // ms
572     vector<int32_t> videoVals = {240, 240, 240, 120, 120, 120, 120, 180, 180,
573         120, 180, 120, 60, 120, 60, 60, 60, 60, 60, 60, 60};
574     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
575     ASSERT_NE(sharedMem_, nullptr);
576     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
577         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
578             ret_ = demuxer_->SeekToTime(*toPts, *mode);
579             if (ret_ != AV_ERR_OK) {
580                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
581                 continue;
582             }
583             ReadData();
584             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
585             ASSERT_EQ(frames_[0], videoVals[numbers_]);
586             numbers_ += 1;
587             RemoveValue();
588             selectedTrackIds_.clear();
589         }
590     }
591 }
592 
593 /**
594  * @tc.name: Demuxer_SeekToTime_1182
595  * @tc.desc: seek to the specified time(h264+mp3(mkv) fd)
596  * @tc.type: FUNC
597  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1182, TestSize.Level1)598 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1182, TestSize.Level1)
599 {
600     InitResource(g_mkvAvcMp3Path, LOCAL);
601     ASSERT_TRUE(initStatus_);
602     SetInitValue();
603     for (auto idx : selectedTrackIds_) {
604         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
605     }
606     list<int64_t> toPtsList = {0, 2025, 1500, 1958, 2600, 3400, 3992, 4100}; // ms
607     vector<int32_t> videoVals = {239, 239, 239, 59, 119, 119, 119, 179, 179, 119, 179, 119,
608         59, 119, 59, 59, 59, 59, 59, 59, 59};
609     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
610     ASSERT_NE(sharedMem_, nullptr);
611     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
612         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
613             ret_ = demuxer_->SeekToTime(*toPts, *mode);
614             if (ret_ != AV_ERR_OK) {
615                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
616                 continue;
617             }
618             ReadData();
619             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
620             ASSERT_EQ(frames_[0], videoVals[numbers_]);
621             numbers_ += 1;
622             RemoveValue();
623             selectedTrackIds_.clear();
624         }
625     }
626 }
627 
628 /**
629  * @tc.name: Demuxer_SeekToTime_1183
630  * @tc.desc: seek to the specified time(h265+aac(mkv) uri)
631  * @tc.type: FUNC
632  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1183, TestSize.Level1)633 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1183, TestSize.Level1)
634 {
635     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
636         return;
637     }
638     InitResource(g_mkvHevcAccUri, URI);
639     ASSERT_TRUE(initStatus_);
640     SetInitValue();
641     for (auto idx : selectedTrackIds_) {
642         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
643     }
644     list<int64_t> toPtsList = {0, 1000, 2000, 1500, 2160, 3630, 2850, 4017, 4300}; // ms
645     vector<int32_t> videoVals = {242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
646         242, 242, 242, 242, 242, 242, 242, 242, 242};
647     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
648     ASSERT_NE(sharedMem_, nullptr);
649     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
650         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
651             ret_ = demuxer_->SeekToTime(*toPts, *mode);
652             if (ret_ != AV_ERR_OK) {
653                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
654                 continue;
655             }
656             ReadData();
657             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
658             ASSERT_EQ(frames_[0], videoVals[numbers_]);
659             numbers_ += 1;
660             RemoveValue();
661             selectedTrackIds_.clear();
662         }
663     }
664 }
665 
666 /**
667  * @tc.name: Demuxer_SeekToTime_1184
668  * @tc.desc: seek to the specified time(h264+opus(mkv) uri)
669  * @tc.type: FUNC
670  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1184, TestSize.Level1)671 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1184, TestSize.Level1)
672 {
673     InitResource(g_mkvAvcOpusUri, URI);
674     ASSERT_TRUE(initStatus_);
675     SetInitValue();
676     for (auto idx : selectedTrackIds_) {
677         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
678     }
679     list<int64_t> toPtsList = {0, 2000, 1500, 1720, 2700, 3980, 4000, 4100}; // ms
680     vector<int32_t> videoVals = {240, 240, 240, 120, 120, 120, 120, 180, 180,
681         120, 180, 120, 60, 120, 60, 60, 60, 60, 60, 60, 60};
682     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
683     ASSERT_NE(sharedMem_, nullptr);
684     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
685         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
686             ret_ = demuxer_->SeekToTime(*toPts, *mode);
687             if (ret_ != AV_ERR_OK) {
688                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
689                 continue;
690             }
691             ReadData();
692             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
693             ASSERT_EQ(frames_[0], videoVals[numbers_]);
694             numbers_ += 1;
695             RemoveValue();
696             selectedTrackIds_.clear();
697         }
698     }
699 }
700 
701 /**
702  * @tc.name: Demuxer_SeekToTime_1185
703  * @tc.desc: seek to the specified time(h264+mp3(mkv) uri)
704  * @tc.type: FUNC
705  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1185, TestSize.Level1)706 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1185, TestSize.Level1)
707 {
708     InitResource(g_mkvAvcMp3Uri, URI);
709     ASSERT_TRUE(initStatus_);
710     SetInitValue();
711     for (auto idx : selectedTrackIds_) {
712         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
713     }
714     list<int64_t> toPtsList = {0, 2025, 1500, 1958, 2600, 3400, 3992, 4100}; // ms
715     vector<int32_t> videoVals = {239, 239, 239, 59, 119, 119, 119, 179, 179, 119, 179, 119,
716         59, 119, 59, 59, 59, 59, 59, 59, 59};
717     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
718     ASSERT_NE(sharedMem_, nullptr);
719     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
720         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
721             ret_ = demuxer_->SeekToTime(*toPts, *mode);
722             if (ret_ != AV_ERR_OK) {
723                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
724                 continue;
725             }
726             ReadData();
727             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
728             ASSERT_EQ(frames_[0], videoVals[numbers_]);
729             numbers_ += 1;
730             RemoveValue();
731             selectedTrackIds_.clear();
732         }
733     }
734 }
735 
736 /**
737  * @tc.name: Demuxer_SeekToTime_1190
738  * @tc.desc: seek to the specified time(hdrvivid mp4 fd)
739  * @tc.type: FUNC
740  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1190, TestSize.Level1)741 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1190, TestSize.Level1)
742 {
743     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
744         return;
745     }
746     InitResource(g_hdrVividPath, LOCAL);
747     ASSERT_TRUE(initStatus_);
748     SetInitValue();
749     for (auto idx : selectedTrackIds_) {
750         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
751     }
752     list<int64_t> toPtsList = {0, 1166, 2000, 1500, 2666, 2800}; // ms
753     vector<int32_t> videoVals = {76, 76, 76, 16, 46, 46, 16, 16, 16, 16, 46, 46, 16, 16};
754     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
755     ASSERT_NE(sharedMem_, nullptr);
756     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
757         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
758             ret_ = demuxer_->SeekToTime(*toPts, *mode);
759             if (ret_ != AV_ERR_OK) {
760                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
761                 continue;
762             }
763             ReadData();
764             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
765             ASSERT_EQ(frames_[0], videoVals[numbers_]);
766             numbers_ += 1;
767             RemoveValue();
768             selectedTrackIds_.clear();
769         }
770     }
771 }
772 
773 /**
774  * @tc.name: Demuxer_SeekToTime_1191
775  * @tc.desc: seek to the specified time(hdrvivid mp4 uri)
776  * @tc.type: FUNC
777  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1191, TestSize.Level1)778 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1191, TestSize.Level1)
779 {
780     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
781         return;
782     }
783     InitResource(g_hdrVividUri, URI);
784     ASSERT_TRUE(initStatus_);
785     SetInitValue();
786     for (auto idx : selectedTrackIds_) {
787         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
788     }
789     list<int64_t> toPtsList = {0, 1166, 2000, 1500, 2666, 2800}; // ms
790     vector<int32_t> videoVals = {76, 76, 76, 16, 46, 46, 16, 16, 16, 16, 46, 46, 16, 16};
791     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
792     ASSERT_NE(sharedMem_, nullptr);
793     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
794         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
795             ret_ = demuxer_->SeekToTime(*toPts, *mode);
796             if (ret_ != AV_ERR_OK) {
797                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
798                 continue;
799             }
800             ReadData();
801             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
802             ASSERT_EQ(frames_[0], videoVals[numbers_]);
803             numbers_ += 1;
804             RemoveValue();
805             selectedTrackIds_.clear();
806         }
807     }
808 }
809 
810 /**
811  * @tc.name: Demuxer_SeekToTime_1192
812  * @tc.desc: seek to the specified time(h265 ts fd)
813  * @tc.type: FUNC
814  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1192, TestSize.Level1)815 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1192, TestSize.Level1)
816 {
817     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
818         return;
819     }
820     InitResource(g_tsHevcAacPath, LOCAL);
821     ASSERT_TRUE(initStatus_);
822     SetInitValue();
823     for (auto idx : selectedTrackIds_) {
824         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
825     }
826     list<int64_t> toPtsList = {0, 1500, 10000, 4600}; // ms
827     vector<int32_t> videoVals = {303, 303, 303, 258, 258, 258, 3, 3, 3, 165, 165, 165};
828     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
829     ASSERT_NE(sharedMem_, nullptr);
830     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
831         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
832             ret_ = demuxer_->SeekToTime(*toPts, *mode);
833             if (ret_ != AV_ERR_OK) {
834                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
835                 continue;
836             }
837             ReadData();
838             printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
839             ASSERT_EQ(frames_[0], videoVals[numbers_]);
840             numbers_ += 1;
841             RemoveValue();
842             selectedTrackIds_.clear();
843         }
844     }
845     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
846     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
847 }
848 
849 /**
850  * @tc.name: Demuxer_SeekToTime_1193
851  * @tc.desc: seek to the specified time(h265 ts uri)
852  * @tc.type: FUNC
853  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1193, TestSize.Level1)854 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1193, TestSize.Level1)
855 {
856     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
857         return;
858     }
859     InitResource(g_tsHevcAacUri, URI);
860     ASSERT_TRUE(initStatus_);
861     SetInitValue();
862     for (auto idx : selectedTrackIds_) {
863         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
864     }
865     list<int64_t> toPtsList = {0, 1500, 10000, 4600}; // ms
866     vector<int32_t> videoVals = {303, 303, 303, 258, 258, 258, 3, 3, 3, 165, 165, 165};
867     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
868     ASSERT_NE(sharedMem_, nullptr);
869     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
870         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
871             ret_ = demuxer_->SeekToTime(*toPts, *mode);
872             if (ret_ != AV_ERR_OK) {
873                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
874                 continue;
875             }
876             ReadData();
877             printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
878             ASSERT_EQ(frames_[0], videoVals[numbers_]);
879             numbers_ += 1;
880             RemoveValue();
881             selectedTrackIds_.clear();
882         }
883     }
884     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
885     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
886 }
887 
888 /**
889  * @tc.name: Demuxer_SeekToTime_1198
890  * @tc.desc: seek to the specified time(h265 fmp4 fd)
891  * @tc.type: FUNC
892  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1198, TestSize.Level1)893 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1198, TestSize.Level1)
894 {
895     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
896         return;
897     }
898     InitResource(g_fmp4HevcPath, LOCAL);
899     ASSERT_TRUE(initStatus_);
900     SetInitValue();
901     for (auto idx : selectedTrackIds_) {
902         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
903     }
904     list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms
905     vector<int32_t> videoVals = {604, 604, 604, 107, 358, 358, 107, 358, 107, 358, 604, 604};
906     vector<int32_t> audioVals = {433, 433, 433, 78, 259, 259, 78, 259, 78, 258, 433, 433};
907     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
908     ASSERT_NE(sharedMem_, nullptr);
909     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
910         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
911             ret_ = demuxer_->SeekToTime(*toPts, *mode);
912             if (ret_ != AV_ERR_OK) {
913                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
914                 continue;
915             }
916             ReadData();
917             printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
918             printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]);
919             ASSERT_EQ(frames_[0], videoVals[numbers_]);
920             ASSERT_EQ(frames_[1], audioVals[numbers_]);
921             numbers_ += 1;
922             RemoveValue();
923             selectedTrackIds_.clear();
924         }
925     }
926     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
927     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
928 }
929 
930 /**
931  * @tc.name: Demuxer_SeekToTime_1199
932  * @tc.desc: seek to the specified time(h265 fmp4 uri)
933  * @tc.type: FUNC
934  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1199, TestSize.Level1)935 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1199, TestSize.Level1)
936 {
937     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
938         return;
939     }
940     InitResource(g_fmp4HevcUri, URI);
941     ASSERT_TRUE(initStatus_);
942     SetInitValue();
943     for (auto idx : selectedTrackIds_) {
944         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
945     }
946     list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms
947     vector<int32_t> videoVals = {604, 604, 604, 107, 358, 358, 107, 358, 107, 358, 604, 604};
948     vector<int32_t> audioVals = {433, 433, 433, 78, 259, 259, 78, 259, 78, 258, 433, 433};
949     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
950     ASSERT_NE(sharedMem_, nullptr);
951     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
952         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
953             ret_ = demuxer_->SeekToTime(*toPts, *mode);
954             if (ret_ != AV_ERR_OK) {
955                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
956                 continue;
957             }
958             ReadData();
959             printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
960             printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]);
961             ASSERT_EQ(frames_[0], videoVals[numbers_]);
962             ASSERT_EQ(frames_[1], audioVals[numbers_]);
963             numbers_ += 1;
964             RemoveValue();
965             selectedTrackIds_.clear();
966         }
967     }
968     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
969     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
970 }
971 
972 /**
973  * @tc.name: Demuxer_SeekToTime_1207
974  * @tc.desc: seek to the specified time(doublevivid fd)
975  * @tc.type: FUNC
976  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1207, TestSize.Level1)977 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1207, TestSize.Level1)
978 {
979     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
980         return;
981     }
982     InitResource(g_doubleVividPath, LOCAL);
983     ASSERT_TRUE(initStatus_);
984     SetInitValue();
985     for (auto idx : selectedTrackIds_) {
986         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
987     }
988     list<int64_t> toPtsList = {0, 1166, 2000, 1500, 2666, 2800}; // ms
989     vector<int32_t> videoVals = {76, 76, 76, 46, 46, 46, 16, 46, 16, 16, 46, 46, 16, 16};
990     vector<int32_t> audioVals = {116, 116, 116, 65, 66, 65, 22, 66, 22, 22, 66, 66, 23, 23};
991     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
992     ASSERT_NE(sharedMem_, nullptr);
993     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
994         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
995             ret_ = demuxer_->SeekToTime(*toPts, *mode);
996             if (ret_ != AV_ERR_OK) {
997                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
998                 continue;
999             }
1000             ReadData();
1001             printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
1002             printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]);
1003             ASSERT_EQ(frames_[0], videoVals[numbers_]);
1004             ASSERT_EQ(frames_[1], audioVals[numbers_]);
1005             numbers_ += 1;
1006             RemoveValue();
1007             selectedTrackIds_.clear();
1008         }
1009     }
1010     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1011     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1012 }
1013 
1014 /**
1015  * @tc.name: Demuxer_SeekToTime_1208
1016  * @tc.desc: seek to the specified time(doublevivid fd)
1017  * @tc.type: FUNC
1018  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1208, TestSize.Level1)1019 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1208, TestSize.Level1)
1020 {
1021     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1022         return;
1023     }
1024     InitResource(g_doubleVividUri, URI);
1025     ASSERT_TRUE(initStatus_);
1026     SetInitValue();
1027     for (auto idx : selectedTrackIds_) {
1028         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
1029     }
1030     list<int64_t> toPtsList = {0, 1166, 2000, 1500, 2666, 2800}; // ms
1031     vector<int32_t> videoVals = {76, 76, 76, 46, 46, 46, 16, 46, 16, 16, 46, 46, 16, 16};
1032     vector<int32_t> audioVals = {116, 116, 116, 65, 66, 65, 22, 66, 22, 22, 66, 66, 23, 23};
1033     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1034     ASSERT_NE(sharedMem_, nullptr);
1035     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1036         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1037             ret_ = demuxer_->SeekToTime(*toPts, *mode);
1038             if (ret_ != AV_ERR_OK) {
1039                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1040                 continue;
1041             }
1042             ReadData();
1043             printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
1044             printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]);
1045             ASSERT_EQ(frames_[0], videoVals[numbers_]);
1046             ASSERT_EQ(frames_[1], audioVals[numbers_]);
1047             numbers_ += 1;
1048             RemoveValue();
1049             selectedTrackIds_.clear();
1050         }
1051     }
1052     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1053     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1054 }
1055 
1056 /**
1057  * @tc.name: Demuxer_ReadSample_1401
1058  * @tc.desc: copy current sample to buffer(flv_enhanced)
1059  * @tc.type: FUNC
1060  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1401, TestSize.Level1)1061 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1401, TestSize.Level1)
1062 {
1063     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1064         return;
1065     }
1066     InitResource(g_flvPath, LOCAL);
1067     ASSERT_TRUE(initStatus_);
1068     ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1069     ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1070     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1071     ASSERT_NE(sharedMem_, nullptr);
1072     SetInitValue();
1073     while (!isEOS(eosFlag_)) {
1074         for (auto idx : selectedTrackIds_) {
1075             ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1076             CountFrames(idx);
1077         }
1078     }
1079     printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1080     printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
1081     ASSERT_EQ(frames_[0], 76);
1082     ASSERT_EQ(frames_[1], 113);
1083     ASSERT_EQ(keyFrames_[0], 1);
1084     ASSERT_EQ(keyFrames_[1], 113);
1085     RemoveValue();
1086 }
1087 
1088 /**
1089  * @tc.name: Demuxer_ReadSample_1402
1090  * @tc.desc: copy current sample to buffer(flv_enhanced uri)
1091  * @tc.type: FUNC
1092  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1402, TestSize.Level1)1093 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1402, TestSize.Level1)
1094 {
1095     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1096         return;
1097     }
1098     InitResource(g_flvUri, URI);
1099     ASSERT_TRUE(initStatus_);
1100     ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1101     ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1102     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1103     ASSERT_NE(sharedMem_, nullptr);
1104     SetInitValue();
1105     while (!isEOS(eosFlag_)) {
1106         for (auto idx : selectedTrackIds_) {
1107             ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1108             CountFrames(idx);
1109         }
1110     }
1111     printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1112     printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
1113     ASSERT_EQ(frames_[0], 76);
1114     ASSERT_EQ(frames_[1], 113);
1115     ASSERT_EQ(keyFrames_[0], 1);
1116     ASSERT_EQ(keyFrames_[1], 113);
1117     RemoveValue();
1118 }
1119 
1120 /**
1121  * @tc.name: Demuxer_SeekToTime_1203
1122  * @tc.desc: seek to the specified time(h265 flv uri)
1123  * @tc.type: FUNC
1124  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1203, TestSize.Level1)1125 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1203, TestSize.Level1)
1126 {
1127     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1128         return;
1129     }
1130     InitResource(g_flvUri, URI);
1131     ASSERT_TRUE(initStatus_);
1132     SetInitValue();
1133     for (auto idx : selectedTrackIds_) {
1134         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
1135     }
1136     list<int64_t> toPtsList = {0, 1500, 1000, 1740, 1970, 2100}; // ms
1137     vector<int32_t> videoVals = {76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76};
1138     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1139     ASSERT_NE(sharedMem_, nullptr);
1140     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1141         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1142             ret_ = demuxer_->SeekToTime(*toPts, *mode);
1143             if (ret_ != AV_ERR_OK) {
1144                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1145                 continue;
1146             }
1147             ReadData();
1148             printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
1149             ASSERT_EQ(frames_[0], videoVals[numbers_]);
1150             numbers_ += 1;
1151             RemoveValue();
1152             selectedTrackIds_.clear();
1153         }
1154     }
1155     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1156     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1157 }
1158 
1159 /**
1160  * @tc.name: Demuxer_SeekToTime_1204
1161  * @tc.desc: seek to the specified time(h265 flv local)
1162  * @tc.type: FUNC
1163  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1204, TestSize.Level1)1164 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1204, TestSize.Level1)
1165 {
1166     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1167         return;
1168     }
1169     InitResource(g_flvPath, LOCAL);
1170     ASSERT_TRUE(initStatus_);
1171     SetInitValue();
1172     for (auto idx : selectedTrackIds_) {
1173         ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
1174     }
1175     list<int64_t> toPtsList = {0, 1500, 1000, 1740, 1970, 2100}; // ms
1176     vector<int32_t> videoVals = {76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76};
1177     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1178     ASSERT_NE(sharedMem_, nullptr);
1179     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1180         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1181             ret_ = demuxer_->SeekToTime(*toPts, *mode);
1182             if (ret_ != AV_ERR_OK) {
1183                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1184                 continue;
1185             }
1186             ReadData();
1187             printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
1188             ASSERT_EQ(frames_[0], videoVals[numbers_]);
1189             numbers_ += 1;
1190             RemoveValue();
1191             selectedTrackIds_.clear();
1192         }
1193     }
1194     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1195     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1196 }
1197 
1198 /**
1199  * @tc.name: Demuxer_ReadSample_1412
1200  * @tc.desc: copy current sample to buffer(h265 hls uri)
1201  * @tc.type: FUNC
1202  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1412, TestSize.Level1)1203 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1412, TestSize.Level1)
1204 {
1205     if (g_hls.find(TEST_URI_PATH2) != std::string::npos) {
1206         return;
1207     }
1208     InitResource(g_hls, URI);
1209     ASSERT_TRUE(initStatus_);
1210     ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1211     ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1212     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1213     ASSERT_NE(sharedMem_, nullptr);
1214     SetInitValue();
1215     while (!isEOS(eosFlag_)) {
1216         for (auto idx : selectedTrackIds_) {
1217             ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1218             CountFrames(idx);
1219         }
1220     }
1221     printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1222     printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
1223     ASSERT_EQ(frames_[0], 602);
1224     ASSERT_EQ(frames_[1], 433);
1225     ASSERT_EQ(keyFrames_[0], 3);
1226     ASSERT_EQ(keyFrames_[1], 433);
1227     RemoveValue();
1228 }
1229 
1230 /**
1231  * @tc.name: Demuxer_SeekToTime_1413
1232  * @tc.desc: seek to the specified time(h265 hls uri)
1233  * @tc.type: FUNC
1234  */
HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1413, TestSize.Level1)1235 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1413, TestSize.Level1)
1236 {
1237     if (g_hls.find(TEST_URI_PATH2) != std::string::npos) {
1238         return;
1239     }
1240     InitResource(g_hls, URI);
1241     ASSERT_TRUE(initStatus_);
1242     ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1243     ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1244     list<int64_t> toPtsList = {0, 4500, 7000, 2000, 10000}; // ms
1245     vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602, 102, 102};
1246     vector<int32_t> audioVals = {433, 433, 433, 74, 254, 254, 74, 254, 74, 253, 433, 433, 75, 75};
1247     sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1248     ASSERT_NE(sharedMem_, nullptr);
1249     for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1250         for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1251             ret_ = demuxer_->SeekToTime(*toPts, *mode);
1252             if (ret_ != AV_ERR_OK) {
1253                 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1254                 continue;
1255             }
1256             ReadData();
1257             printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1258             printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]);
1259             ASSERT_EQ(frames_[0], videoVals[numbers_]);
1260             ASSERT_EQ(frames_[1], audioVals[numbers_]);
1261             numbers_ += 1;
1262             RemoveValue();
1263             selectedTrackIds_.clear();
1264         }
1265     }
1266     ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1267     ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1268 }
1269 
1270 /**
1271  * @tc.name: Demuxer_ReadSample_1200
1272  * @tc.desc: copy current sample to buffer, local
1273  * @tc.type: FUNC
1274  */
HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1700, TestSize.Level1)1275 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1700, TestSize.Level1)
1276 {
1277     if (access(g_mp4265InfoParsePath.c_str(), F_OK) != 0) {
1278         return;
1279     }
1280     ReadSample(g_mp4265InfoParsePath, LOCAL, true);
1281     for (auto idx : selectedTrackIds_) {
1282         ASSERT_EQ(frames_[idx], infoMap["mp4265InfoParse"]["frames"][idx]);
1283         ASSERT_EQ(keyFrames_[idx], infoMap["mp4265InfoParse"]["kFrames"][idx]);
1284     }
1285     RemoveValue();
1286     selectedTrackIds_.clear();
1287 }
1288 } // namespace
1289