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