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