1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "avdemuxer.h"
19 #include "avsource.h"
20 #include "meta/format.h"
21 #include "avcodec_errors.h"
22 #include "avcodec_common.h"
23 #include "buffer/avsharedmemory.h"
24 #include "buffer/avsharedmemorybase.h"
25 #include "securec.h"
26 #include "inner_demuxer_sample.h"
27
28 #include <iostream>
29 #include <cstdio>
30 #include <string>
31 #include <fcntl.h>
32
33 using namespace std;
34 using namespace OHOS;
35 using namespace OHOS::MediaAVCodec;
36 using namespace OHOS::Media;
37 using namespace testing::ext;
38
39 namespace {
40 const int64_t SOURCE_OFFSET = 0;
41 static std::shared_ptr<AVSource> source = nullptr;
42 static std::shared_ptr<AVDemuxer> demuxer = nullptr;
43 static const string TEST_FILE_PATH = "/data/test/media/";
44 string g_doubleHevcPath = TEST_FILE_PATH + string("double_hevc.mp4");
45 string g_singleHevcPath = TEST_FILE_PATH + string("single_60.mp4");
46 string g_singleRkPath = TEST_FILE_PATH + string("single_rk.mp4");
47 string g_xmPath = TEST_FILE_PATH + string("xm.mp4");
48 string g_doubleVividPath = TEST_FILE_PATH + string("double_vivid.mp4");
49 static int32_t g_apeVersion = 73728;
50 } // namespace
51
52 namespace {
53 class DemuxerInnerFuncNdkTest : public testing::Test {
54 public:
55 // SetUpTestCase: Called before all test cases
56 static void SetUpTestCase(void);
57 // TearDownTestCase: Called after all test case
58 static void TearDownTestCase(void);
59 // SetUp: Called before each test cases
60 void SetUp(void);
61 // TearDown: Called after each test cases
62 void TearDown(void);
63
64 public:
65 int32_t fd_ = -1;
66 int64_t size;
67 };
68
SetUpTestCase()69 void DemuxerInnerFuncNdkTest::SetUpTestCase() {}
TearDownTestCase()70 void DemuxerInnerFuncNdkTest::TearDownTestCase() {}
SetUp()71 void DemuxerInnerFuncNdkTest::SetUp() {}
TearDown()72 void DemuxerInnerFuncNdkTest::TearDown()
73 {
74 if (fd_ > 0) {
75 close(fd_);
76 fd_ = -1;
77 }
78
79 if (source != nullptr) {
80 source = nullptr;
81 }
82
83 if (demuxer != nullptr) {
84 demuxer = nullptr;
85 }
86 }
87 } // namespace
88
89 namespace {
90 /**
91 * @tc.number : DEMUXER_ILLEGAL_FUNC_0100
92 * @tc.name : check video format from double
93 * @tc.desc : func test
94 */
95 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_ILLEGAL_FUNC_0100, TestSize.Level0)
96 {
97 fd_ = open(g_doubleHevcPath.c_str(), O_RDONLY);
98 struct stat fileStatus {};
99 if (stat(g_doubleHevcPath.c_str(), &fileStatus) == 0) {
100 size = static_cast<int64_t>(fileStatus.st_size);
101 }
102 source = AVSourceFactory::CreateWithFD(fd_, SOURCE_OFFSET, size);
103
104 ASSERT_NE(nullptr, source);
105 Format format_;
106 int32_t ret = source->GetSourceFormat(format_);
107 ASSERT_EQ(AVCS_ERR_OK, ret);
108
109 float longitude = 0.0;
110 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LONGITUDE, longitude));
111 ASSERT_EQ(longitude, float(120.201302));
112
113 float latitude = 0.0;
114 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LATITUDE, latitude));
115 ASSERT_EQ(latitude, float(30.188101));
116
117 string genre;
118 ASSERT_TRUE(format_.GetStringValue(Media::Tag::MEDIA_GENRE, genre));
119 ASSERT_EQ(genre, "AAAAAA{marketing-name:\"AABBAABBAABBAABBAA\",param-hw-ext"\
120 ":{camera-position-tag:2},param-use-tag:TypeNormalVideo}");
121
122 Format metaFormat_;
123 ret = source->GetUserMeta(metaFormat_);
124 ASSERT_EQ(AVCS_ERR_OK, ret);
125
126 std::string manufacturer;
127 ASSERT_TRUE(metaFormat_.GetStringValue("com.abababa.manufacturer", manufacturer));
128 ASSERT_EQ(manufacturer, "ABCDEF");
129 std::string marketingName;
130 ASSERT_TRUE(metaFormat_.GetStringValue("com.abababa.marketing_name", marketingName));
131 ASSERT_EQ(marketingName, "AABBAABBAABBAABBAA");
132 std::string model;
133 ASSERT_TRUE(metaFormat_.GetStringValue("com.abababa.model", model));
134 ASSERT_EQ(model, "ABABABAB");
135 std::string version;
136 ASSERT_TRUE(metaFormat_.GetStringValue("com.abababa.version", version));
137 ASSERT_EQ(version, "12");
138 }
139
140 /**
141 * @tc.number : DEMUXER_ILLEGAL_FUNC_0200
142 * @tc.name : check video format from single
143 * @tc.desc : func test
144 */
145 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_ILLEGAL_FUNC_0200, TestSize.Level0)
146 {
147 fd_ = open(g_singleHevcPath.c_str(), O_RDONLY);
148 struct stat fileStatus {};
149 if (stat(g_singleHevcPath.c_str(), &fileStatus) == 0) {
150 size = static_cast<int64_t>(fileStatus.st_size);
151 }
152 source = AVSourceFactory::CreateWithFD(fd_, SOURCE_OFFSET, size);
153
154 ASSERT_NE(nullptr, source);
155 Format format_;
156 int32_t ret = source->GetSourceFormat(format_);
157 ASSERT_EQ(AVCS_ERR_OK, ret);
158
159 float longitude = 0.0;
160 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LONGITUDE, longitude));
161 ASSERT_EQ(longitude, float(120.000000));
162
163 float latitude = 0.0;
164 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LATITUDE, latitude));
165 ASSERT_EQ(latitude, float(30.000000));
166
167 Format metaFormat_;
168 ret = source->GetUserMeta(metaFormat_);
169 ASSERT_EQ(AVCS_ERR_OK, ret);
170 }
171
172 /**
173 * @tc.number : DEMUXER_ILLEGAL_FUNC_0300
174 * @tc.name : check video format from rk
175 * @tc.desc : func test
176 */
177 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_ILLEGAL_FUNC_0300, TestSize.Level2)
178 {
179 fd_ = open(g_singleRkPath.c_str(), O_RDONLY);
180 struct stat fileStatus {};
181 if (stat(g_singleRkPath.c_str(), &fileStatus) == 0) {
182 size = static_cast<int64_t>(fileStatus.st_size);
183 }
184 source = AVSourceFactory::CreateWithFD(fd_, SOURCE_OFFSET, size);
185 ASSERT_NE(nullptr, source);
186 Format format_;
187 int32_t ret = source->GetSourceFormat(format_);
188 ASSERT_EQ(AVCS_ERR_OK, ret);
189
190 float longitude = 0.0;
191 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LONGITUDE, longitude));
192 ASSERT_EQ(longitude, float(0.000000));
193
194 float latitude = 0.0;
195 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LATITUDE, latitude));
196 ASSERT_EQ(latitude, float(0.000000));
197 }
198
199 /**
200 * @tc.number : DEMUXER_ILLEGAL_FUNC_0400
201 * @tc.name : check video format from xm
202 * @tc.desc : func test
203 */
204 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_ILLEGAL_FUNC_0400, TestSize.Level2)
205 {
206 fd_ = open(g_xmPath.c_str(), O_RDONLY);
207 struct stat fileStatus {};
208 if (stat(g_xmPath.c_str(), &fileStatus) == 0) {
209 size = static_cast<int64_t>(fileStatus.st_size);
210 }
211 source = AVSourceFactory::CreateWithFD(fd_, SOURCE_OFFSET, size);
212 ASSERT_NE(nullptr, source);
213 Format format_;
214 int32_t ret = source->GetSourceFormat(format_);
215 ASSERT_EQ(AVCS_ERR_OK, ret);
216 float longitude = 0.0;
217 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LONGITUDE, longitude));
218 ASSERT_EQ(longitude, float(120.201302));
219 float latitude = 0.0;
220 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LATITUDE, latitude));
221 ASSERT_EQ(latitude, float(30.188101));
222 Format metaFormat_;
223 ret = source->GetUserMeta(metaFormat_);
224 ASSERT_EQ(AVCS_ERR_OK, ret);
225 }
226
227 /**
228 * @tc.number : DEMUXER_ILLEGAL_FUNC_0500
229 * @tc.name : check video format from double vivid
230 * @tc.desc : func test
231 */
232 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_ILLEGAL_FUNC_0500, TestSize.Level2)
233 {
234 fd_ = open(g_doubleVividPath.c_str(), O_RDONLY);
235 struct stat fileStatus {};
236 if (stat(g_doubleVividPath.c_str(), &fileStatus) == 0) {
237 size = static_cast<int64_t>(fileStatus.st_size);
238 }
239 source = AVSourceFactory::CreateWithFD(fd_, SOURCE_OFFSET, size);
240
241 ASSERT_NE(nullptr, source);
242 Format format_;
243 int32_t ret = source->GetSourceFormat(format_);
244 ASSERT_EQ(AVCS_ERR_OK, ret);
245
246 float longitude = 0.0;
247 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LONGITUDE, longitude));
248 ASSERT_EQ(longitude, float(120.201401));
249
250 float latitude = 0.0;
251 ASSERT_TRUE(format_.GetFloatValue(Media::Tag::MEDIA_LATITUDE, latitude));
252 ASSERT_EQ(latitude, float(30.188101));
253
254 string genre;
255 ASSERT_TRUE(format_.GetStringValue(Media::Tag::MEDIA_GENRE, genre));
256 ASSERT_EQ(genre, "AABBAA{marketing-name:\"AABBAABBAABBAABABA\",param-AA-ext"\
257 ":{camera-position-tag:2},param-use-tag:TypeNormalVideo}");
258 }
259
260 /**
261 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0010
262 * @tc.name : get has_timed_meta without meta video track source
263 * @tc.desc : func test
264 */
265 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0010, TestSize.Level0)
266 {
267 auto demuxerSample = make_unique<InnerDemuxerSample>();
268 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_avc.mp4", true), AVCS_ERR_OK);
269 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 0);
270 }
271
272 /**
273 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0020
274 * @tc.name : get has_timed_meta without meta audio track source
275 * @tc.desc : func test
276 */
277 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0020, TestSize.Level1)
278 {
279 auto demuxerSample = make_unique<InnerDemuxerSample>();
280 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/NoTimedmetadataAudio.mp4", true), AVCS_ERR_OK);
281 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 0);
282 }
283
284 /**
285 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0030
286 * @tc.name : get has_timed_meta without meta video+audio track source
287 * @tc.desc : func test
288 */
289 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0030, TestSize.Level1)
290 {
291 auto demuxerSample = make_unique<InnerDemuxerSample>();
292 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_hevc.mp4", true), AVCS_ERR_OK);
293 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 0);
294 }
295
296 /**
297 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0040
298 * @tc.name : get has_timed_meta with meta video track source
299 * @tc.desc : func test
300 */
301 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0040, TestSize.Level1)
302 {
303 auto demuxerSample = make_unique<InnerDemuxerSample>();
304 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/TimedmetadataVideo.mp4", true), AVCS_ERR_OK);
305 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1);
306 }
307
308 /**
309 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0050
310 * @tc.name : get has_timed_meta with meta audio track source
311 * @tc.desc : func test
312 */
313 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0050, TestSize.Level1)
314 {
315 auto demuxerSample = make_unique<InnerDemuxerSample>();
316 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/TimedmetadataAudio.mp4", true), AVCS_ERR_OK);
317 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1);
318 }
319
320 /**
321 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0060
322 * @tc.name : get has_timed_meta with meta video+audio track source
323 * @tc.desc : func test
324 */
325 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0060, TestSize.Level1)
326 {
327 auto demuxerSample = make_unique<InnerDemuxerSample>();
328 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
329 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1);
330 }
331
332 /**
333 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0070
334 * @tc.name : demuxer timed metadata with 1 meta track and video track file-meta track at 0
335 * @tc.desc : func test
336 */
337 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0070, TestSize.Level1)
338 {
339 auto demuxerSample = make_unique<InnerDemuxerSample>();
340 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
341 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1);
342 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(0, 1), 0);
343 ASSERT_EQ(demuxerSample->CheckTimedMeta(0), 0);
344 }
345
346 /**
347 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0080
348 * @tc.name : demuxer timed metadata with 1 meta track and video track file-meta track at 1
349 * @tc.desc : func test
350 */
351 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0080, TestSize.Level1)
352 {
353 auto demuxerSample = make_unique<InnerDemuxerSample>();
354 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track1.mp4", true), AVCS_ERR_OK);
355 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1);
356 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(1, 0), 0);
357 ASSERT_EQ(demuxerSample->CheckTimedMeta(1), 0);
358 }
359
360 /**
361 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0090
362 * @tc.name : demuxer timed metadata with 1 meta track and video track file-meta track at 2
363 * @tc.desc : func test
364 */
365 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0090, TestSize.Level1)
366 {
367 auto demuxerSample = make_unique<InnerDemuxerSample>();
368 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track2.mp4", true), AVCS_ERR_OK);
369 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1);
370 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(2, 0), 0);
371 ASSERT_EQ(demuxerSample->CheckTimedMeta(2), 0);
372 }
373
374 /**
375 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0100
376 * @tc.name : demuxer timed metadata with 2 meta track and video track file
377 * @tc.desc : func test
378 */
379 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0100, TestSize.Level1)
380 {
381 auto demuxerSample = make_unique<InnerDemuxerSample>();
382 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata2Track2.mp4", true), AVCS_ERR_OK);
383 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1);
384 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(2, 0), 0);
385 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(3, 0), 0);
386 ASSERT_EQ(demuxerSample->CheckTimedMeta(3), 0);
387 }
388
389 /**
390 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0010
391 * @tc.name : GetFrameIndexByPresentationTimeUs with ltr h264 source
392 * @tc.desc : func test
393 */
394 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0010, TestSize.Level0)
395 {
396 auto demuxerSample = make_unique<InnerDemuxerSample>();
397 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ltr_frame_avc.mp4", true), AVCS_ERR_OK);
398 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
399 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
400 }
401
402 /**
403 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0020
404 * @tc.name : GetFrameIndexByPresentationTimeUs with one I frame h264 video track source
405 * @tc.desc : func test
406 */
407 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0020, TestSize.Level1)
408 {
409 auto demuxerSample = make_unique<InnerDemuxerSample>();
410 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_one_i_frame_no_audio_avc.mp4", true),
411 AVCS_ERR_OK);
412 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
413 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
414 }
415
416 /**
417 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0030
418 * @tc.name : GetFrameIndexByPresentationTimeUs with one I frame h264 video and audio track source
419 * @tc.desc : func test
420 */
421 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0030, TestSize.Level1)
422 {
423 auto demuxerSample = make_unique<InnerDemuxerSample>();
424 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_one_i_frame_avc.mp4", true), AVCS_ERR_OK);
425 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
426 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
427 }
428
429 /**
430 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0040
431 * @tc.name : GetFrameIndexByPresentationTimeUs with all I frame h264 source
432 * @tc.desc : func test
433 */
434 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0040, TestSize.Level1)
435 {
436 auto demuxerSample = make_unique<InnerDemuxerSample>();
437 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_all_i_frame_avc.mp4", true), AVCS_ERR_OK);
438 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
439 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
440 }
441
442 /**
443 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0050
444 * @tc.name : GetFrameIndexByPresentationTimeUs with IPB h264 source
445 * @tc.desc : func test
446 */
447 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0050, TestSize.Level1)
448 {
449 auto demuxerSample = make_unique<InnerDemuxerSample>();
450 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_avc.mp4", true), AVCS_ERR_OK);
451 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
452 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
453 }
454
455 /**
456 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0060
457 * @tc.name : GetFrameIndexByPresentationTimeUs with 2 layer frame h264 source
458 * @tc.desc : func test
459 */
460 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0060, TestSize.Level1)
461 {
462 auto demuxerSample = make_unique<InnerDemuxerSample>();
463 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_avc.mp4", true), AVCS_ERR_OK);
464 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
465 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
466 }
467
468 /**
469 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0070
470 * @tc.name : GetFrameIndexByPresentationTimeUs with ltr h265 source
471 * @tc.desc : func test
472 */
473 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0070, TestSize.Level1)
474 {
475 auto demuxerSample = make_unique<InnerDemuxerSample>();
476 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ltr_frame_hevc.mp4", true), AVCS_ERR_OK);
477 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
478 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
479 }
480
481 /**
482 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0080
483 * @tc.name : GetFrameIndexByPresentationTimeUs with one I frame h265 video track source
484 * @tc.desc : func test
485 */
486 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0080, TestSize.Level1)
487 {
488 auto demuxerSample = make_unique<InnerDemuxerSample>();
489 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_one_i_frame_no_audio_hevc.mp4", true),
490 AVCS_ERR_OK);
491 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
492 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
493 }
494
495 /**
496 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0090
497 * @tc.name : GetFrameIndexByPresentationTimeUs with one I frame h265 video and audio track source
498 * @tc.desc : func test
499 */
500 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0090, TestSize.Level1)
501 {
502 auto demuxerSample = make_unique<InnerDemuxerSample>();
503 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_one_i_frame_hevc.mp4", true), AVCS_ERR_OK);
504 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
505 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
506 }
507
508 /**
509 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0100
510 * @tc.name : GetFrameIndexByPresentationTimeUs with all I frame h265 source
511 * @tc.desc : func test
512 */
513 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0100, TestSize.Level1)
514 {
515 auto demuxerSample = make_unique<InnerDemuxerSample>();
516 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_all_i_frame_hevc.mp4", true), AVCS_ERR_OK);
517 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
518 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
519 }
520
521 /**
522 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0110
523 * @tc.name : GetFrameIndexByPresentationTimeUs with IPB frame h265 source
524 * @tc.desc : func test
525 */
526 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0110, TestSize.Level1)
527 {
528 auto demuxerSample = make_unique<InnerDemuxerSample>();
529 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_hevc.mp4", true), AVCS_ERR_OK);
530 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
531 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
532 }
533
534 /**
535 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0120
536 * @tc.name : GetFrameIndexByPresentationTimeUs with 2 layer frame frame h265 source
537 * @tc.desc : func test
538 */
539 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0120, TestSize.Level1)
540 {
541 auto demuxerSample = make_unique<InnerDemuxerSample>();
542 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_hevc.mp4", true), AVCS_ERR_OK);
543 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
544 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
545 }
546
547 /**
548 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0130
549 * @tc.name : GetPresentationTimeUsByFrameIndex with ltr h264 source
550 * @tc.desc : func test
551 */
552 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0130, TestSize.Level1)
553 {
554 auto demuxerSample = make_unique<InnerDemuxerSample>();
555 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ltr_frame_avc.mp4", true), AVCS_ERR_OK);
556 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
557 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
558 }
559
560 /**
561 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0140
562 * @tc.name : GetPresentationTimeUsByFrameIndex with one I frame h264 video track source
563 * @tc.desc : func test
564 */
565 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0140, TestSize.Level1)
566 {
567 auto demuxerSample = make_unique<InnerDemuxerSample>();
568 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_one_i_frame_no_audio_avc.mp4", true),
569 AVCS_ERR_OK);
570 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
571 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
572 }
573
574 /**
575 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0150
576 * @tc.name : GetPresentationTimeUsByFrameIndex with one I frame h264 video and audio track source
577 * @tc.desc : func test
578 */
579 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0150, TestSize.Level1)
580 {
581 auto demuxerSample = make_unique<InnerDemuxerSample>();
582 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_one_i_frame_avc.mp4", true), AVCS_ERR_OK);
583 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
584 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
585 }
586
587 /**
588 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0160
589 * @tc.name : GetPresentationTimeUsByFrameIndex with all I frame h264 source
590 * @tc.desc : func test
591 */
592 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0160, TestSize.Level1)
593 {
594 auto demuxerSample = make_unique<InnerDemuxerSample>();
595 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_all_i_frame_avc.mp4", true), AVCS_ERR_OK);
596 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
597 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
598 }
599
600 /**
601 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0170
602 * @tc.name : GetPresentationTimeUsByFrameIndex with IPB h264 source
603 * @tc.desc : func test
604 */
605 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0170, TestSize.Level1)
606 {
607 auto demuxerSample = make_unique<InnerDemuxerSample>();
608 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_avc.mp4", true), AVCS_ERR_OK);
609 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
610 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
611 }
612
613 /**
614 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0180
615 * @tc.name : GetPresentationTimeUsByFrameIndex with 2 layer frame h264 source
616 * @tc.desc : func test
617 */
618 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0180, TestSize.Level1)
619 {
620 auto demuxerSample = make_unique<InnerDemuxerSample>();
621 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_avc.mp4", true), AVCS_ERR_OK);
622 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
623 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
624 }
625
626 /**
627 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0190
628 * @tc.name : GetPresentationTimeUsByFrameIndex with ltr h265 source
629 * @tc.desc : func test
630 */
631 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0190, TestSize.Level1)
632 {
633 auto demuxerSample = make_unique<InnerDemuxerSample>();
634 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ltr_frame_hevc.mp4", true), AVCS_ERR_OK);
635 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
636 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
637 }
638
639 /**
640 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0200
641 * @tc.name : GetPresentationTimeUsByFrameIndex with one I frame h265 video track source
642 * @tc.desc : func test
643 */
644 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0200, TestSize.Level1)
645 {
646 auto demuxerSample = make_unique<InnerDemuxerSample>();
647 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_one_i_frame_no_audio_hevc.mp4", true),
648 AVCS_ERR_OK);
649 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
650 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
651 }
652
653 /**
654 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0210
655 * @tc.name : GetPresentationTimeUsByFrameIndex with one I frame h265 video and audio track source
656 * @tc.desc : func test
657 */
658 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0210, TestSize.Level1)
659 {
660 auto demuxerSample = make_unique<InnerDemuxerSample>();
661 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_one_i_frame_hevc.mp4", true), AVCS_ERR_OK);
662 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
663 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
664 }
665
666 /**
667 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0220
668 * @tc.name : GetPresentationTimeUsByFrameIndex with all I frame h265 source
669 * @tc.desc : func test
670 */
671 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0220, TestSize.Level1)
672 {
673 auto demuxerSample = make_unique<InnerDemuxerSample>();
674 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_all_i_frame_hevc.mp4", true), AVCS_ERR_OK);
675 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
676 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
677 }
678
679 /**
680 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0230
681 * @tc.name : GetPresentationTimeUsByFrameIndex with IPB h265 source
682 * @tc.desc : func test
683 */
684 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0230, TestSize.Level1)
685 {
686 auto demuxerSample = make_unique<InnerDemuxerSample>();
687 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_hevc.mp4", true), AVCS_ERR_OK);
688 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
689 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
690 }
691
692 /**
693 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0240
694 * @tc.name : GetPresentationTimeUsByFrameIndex with 2 layer frame h265 source
695 * @tc.desc : func test
696 */
697 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0240, TestSize.Level1)
698 {
699 auto demuxerSample = make_unique<InnerDemuxerSample>();
700 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_hevc.mp4", true), AVCS_ERR_OK);
701 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
702 ASSERT_EQ(demuxerSample->CheckPtsFromIndex(), AVCS_ERR_OK);
703 }
704
705 /**
706 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0250
707 * @tc.name : GetFrameIndexByPresentationTimeUs with IP h264 source, pts is a close to left value
708 * @tc.desc : func test
709 */
710 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0250, TestSize.Level1)
711 {
712 auto demuxerSample = make_unique<InnerDemuxerSample>();
713 demuxerSample->isPtsCloseLeft = true;
714 demuxerSample->isPtsExist = true;
715 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_avc.mp4", true), AVCS_ERR_OK);
716 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
717 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
718 }
719
720 /**
721 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0260
722 * @tc.name : GetFrameIndexByPresentationTimeUs with IP h264 source, pts is a close to right value
723 * @tc.desc : func test
724 */
725 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0260, TestSize.Level1)
726 {
727 auto demuxerSample = make_unique<InnerDemuxerSample>();
728 demuxerSample->isPtsCloseRight = true;
729 demuxerSample->isPtsExist = true;
730 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_avc.mp4", true), AVCS_ERR_OK);
731 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
732 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
733 }
734
735 /**
736 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0270
737 * @tc.name : GetFrameIndexByPresentationTimeUs with IP h264 source, pts is a close to center value
738 * @tc.desc : func test
739 */
740 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0270, TestSize.Level1)
741 {
742 auto demuxerSample = make_unique<InnerDemuxerSample>();
743 demuxerSample->isPtsCloseCenter = true;
744 demuxerSample->isPtsExist = true;
745 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_avc.mp4", true), AVCS_ERR_OK);
746 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
747 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
748 }
749
750 /**
751 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0280
752 * @tc.name : GetFrameIndexByPresentationTimeUs with IP h265 source, pts is a close to left value
753 * @tc.desc : func test
754 */
755 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0280, TestSize.Level1)
756 {
757 auto demuxerSample = make_unique<InnerDemuxerSample>();
758 demuxerSample->isPtsCloseLeft = true;
759 demuxerSample->isPtsExist = true;
760 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_hevc.mp4", true), AVCS_ERR_OK);
761 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
762 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
763 }
764
765 /**
766 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0290
767 * @tc.name : GetFrameIndexByPresentationTimeUs with IP h265 source, pts is a close to right value
768 * @tc.desc : func test
769 */
770 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0290, TestSize.Level1)
771 {
772 auto demuxerSample = make_unique<InnerDemuxerSample>();
773 demuxerSample->isPtsCloseRight = true;
774 demuxerSample->isPtsExist = true;
775 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_hevc.mp4", true), AVCS_ERR_OK);
776 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
777 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
778 }
779
780 /**
781 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0300
782 * @tc.name : GetFrameIndexByPresentationTimeUs with IP h265 source, pts is a close to center value
783 * @tc.desc : func test
784 */
785 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0300, TestSize.Level1)
786 {
787 auto demuxerSample = make_unique<InnerDemuxerSample>();
788 demuxerSample->isPtsCloseCenter = true;
789 demuxerSample->isPtsExist = true;
790 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_2_layer_frame_hevc.mp4", true), AVCS_ERR_OK);
791 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
792 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
793 }
794
795 /**
796 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0310
797 * @tc.name : GetFrameIndexByPresentationTimeUs with IPB h264 source, pts is a close to left value
798 * @tc.desc : func test
799 */
800 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0310, TestSize.Level1)
801 {
802 auto demuxerSample = make_unique<InnerDemuxerSample>();
803 demuxerSample->isPtsCloseLeft = true;
804 demuxerSample->isPtsExist = true;
805 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_avc.mp4", true), AVCS_ERR_OK);
806 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
807 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
808 }
809
810 /**
811 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0320
812 * @tc.name : GetFrameIndexByPresentationTimeUs with IPB h264 source, pts is a close to right value
813 * @tc.desc : func test
814 */
815 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0320, TestSize.Level1)
816 {
817 auto demuxerSample = make_unique<InnerDemuxerSample>();
818 demuxerSample->isPtsCloseRight = true;
819 demuxerSample->isPtsExist = true;
820 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_avc.mp4", true), AVCS_ERR_OK);
821 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
822 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
823 }
824
825 /**
826 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0330
827 * @tc.name : GetFrameIndexByPresentationTimeUs with IPB h264 source, pts is a close to center value
828 * @tc.desc : func test
829 */
830 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0330, TestSize.Level1)
831 {
832 auto demuxerSample = make_unique<InnerDemuxerSample>();
833 demuxerSample->isPtsCloseCenter = true;
834 demuxerSample->isPtsExist = true;
835 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_avc.mp4", true), AVCS_ERR_OK);
836 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
837 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
838 }
839
840 /**
841 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0340
842 * @tc.name : GetFrameIndexByPresentationTimeUs with IPB h265 source, pts is a close to left value
843 * @tc.desc : func test
844 */
845 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0340, TestSize.Level1)
846 {
847 auto demuxerSample = make_unique<InnerDemuxerSample>();
848 demuxerSample->isPtsCloseLeft = true;
849 demuxerSample->isPtsExist = true;
850 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_hevc.mp4", true), AVCS_ERR_OK);
851 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
852 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
853 }
854
855 /**
856 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0350
857 * @tc.name : GetFrameIndexByPresentationTimeUs with IP h265 source, pts is a close to right value
858 * @tc.desc : func test
859 */
860 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0350, TestSize.Level1)
861 {
862 auto demuxerSample = make_unique<InnerDemuxerSample>();
863 demuxerSample->isPtsCloseRight = true;
864 demuxerSample->isPtsExist = true;
865 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_hevc.mp4", true), AVCS_ERR_OK);
866 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
867 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
868 }
869
870 /**
871 * @tc.number : DEMUXER_PTS_INDEX_INNER_FUNC_0360
872 * @tc.name : GetFrameIndexByPresentationTimeUs with IPB h265 source, pts is a close to center value
873 * @tc.desc : func test
874 */
875 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_PTS_INDEX_INNER_FUNC_0360, TestSize.Level1)
876 {
877 auto demuxerSample = make_unique<InnerDemuxerSample>();
878 demuxerSample->isPtsCloseCenter = true;
879 demuxerSample->isPtsExist = true;
880 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/demuxer_parser_ipb_frame_hevc.mp4", true), AVCS_ERR_OK);
881 ASSERT_EQ(demuxerSample->ReadSampleAndSave(), AVCS_ERR_OK);
882 ASSERT_EQ(demuxerSample->CheckIndexFromPts(), AVCS_ERR_OK);
883 }
884
885 /**
886 * @tc.number : DEMUXER_APE_INNER_FUNC_0050
887 * @tc.name : APE version >= 3.98 && <= 3.99
888 * @tc.desc : func test
889 */
890 HWTEST_F(DemuxerInnerFuncNdkTest, DEMUXER_APE_INNER_FUNC_0050, TestSize.Level1)
891 {
892 auto demuxerSample = make_unique<InnerDemuxerSample>();
893 ASSERT_EQ(demuxerSample->CheckApeSourceData("/data/test/media/audio/ape.ape", g_apeVersion), true);
894 }
895
896 } // namespace