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 #include <iostream>
18 #include <cstdio>
19 #include <string>
20 #include <fcntl.h>
21 #include "inner_demuxer_parser_sample.h"
22 #include "avcodec_errors.h"
23 
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::MediaAVCodec;
28 using namespace OHOS::Media;
29 
30 namespace {
31 static const string TEST_FILE_PATH = "/data/test/media/";
32 const std::string HEVC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_hevc_parser.z.so";
33 string g_file_one_i_frame_avc = TEST_FILE_PATH + string("demuxer_parser_one_i_frame_avc.mp4");
34 string g_file_all_i_frame_avc = TEST_FILE_PATH + string("demuxer_parser_all_i_frame_avc.mp4");
35 string g_file_ipb_frame_avc = TEST_FILE_PATH + string("demuxer_parser_ipb_frame_avc.mp4");
36 string g_file_sdtp_frame_avc = TEST_FILE_PATH + string("demuxer_parser_sdtp_frame_avc.mp4");
37 string g_file_ltr_frame_avc = TEST_FILE_PATH + string("demuxer_parser_ltr_frame_avc.mp4");
38 string g_file_2_layer_frame_avc = TEST_FILE_PATH + string("demuxer_parser_2_layer_frame_avc.mp4");
39 string g_file_3_layer_frame_avc = TEST_FILE_PATH + string("demuxer_parser_3_layer_frame_avc.mp4");
40 string g_file_4_layer_frame_avc = TEST_FILE_PATH + string("demuxer_parser_4_layer_frame_avc.mp4");
41 string g_test_file_ts_avc = TEST_FILE_PATH + string("h264_aac_640.ts");
42 string g_test_file_ts_hevc = TEST_FILE_PATH + string("h265_mp3_640.ts");
43 string g_file_one_i_frame_hevc = TEST_FILE_PATH + string("demuxer_parser_one_i_frame_hevc.mp4");
44 string g_file_all_i_frame_hevc = TEST_FILE_PATH + string("demuxer_parser_all_i_frame_hevc.mp4");
45 string g_file_ipb_frame_hevc = TEST_FILE_PATH + string("demuxer_parser_ipb_frame_hevc.mp4");
46 string g_file_sdtp_frame_hevc = TEST_FILE_PATH + string("demuxer_parser_sdtp_frame_hevc.mp4");
47 string g_file_sdtp_extended_hevc = TEST_FILE_PATH + string("demuxer_parser_sdtp_extended_hevc.mp4");
48 string g_file_ltr_frame_hevc = TEST_FILE_PATH + string("demuxer_parser_ltr_frame_hevc.mp4");
49 string g_file_2_layer_frame_hevc = TEST_FILE_PATH + string("demuxer_parser_2_layer_frame_hevc.mp4");
50 string g_file_3_layer_frame_hevc = TEST_FILE_PATH + string("demuxer_parser_3_layer_frame_hevc.mp4");
51 string g_file_4_layer_frame_hevc = TEST_FILE_PATH + string("demuxer_parser_4_layer_frame_hevc.mp4");
52 string g_file_hdr_1_hevc = TEST_FILE_PATH + string("demuxer_parser_hdr_1_hevc.mp4");
53 string g_file_hdr_2_hevc = TEST_FILE_PATH + string("demuxer_parser_hdr_2_hevc.mp4");
54 } // namespace
55 
56 namespace {
57 class InnerParsercNdkTest : public testing::Test {
58 public:
59     // SetUpTestCase: Called before all test cases
60     static void SetUpTestCase(void);
61     // TearDownTestCase: Called after all test case
62     static void TearDownTestCase(void);
63     // SetUp: Called before each test cases
64     void SetUp(void);
65     // TearDown: Called after each test cases
66     void TearDown(void);
67 };
68 
SetUpTestCase()69 void InnerParsercNdkTest::SetUpTestCase() {}
TearDownTestCase()70 void InnerParsercNdkTest::TearDownTestCase() {}
SetUp()71 void InnerParsercNdkTest::SetUp() {}
TearDown()72 void InnerParsercNdkTest::TearDown() {}
73 } // namespace
74 
75 namespace {
76 /**
77  * @tc.number    : DEMUXER_REFERENCE_H264_API_0010
78  * @tc.name      : StartRefParser with non-existent pts
79  * @tc.desc      : api test
80  */
81 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_API_0010, TestSize.Level1)
82 {
83     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
84         return;
85     }
86     auto parserSample = make_unique<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
87     ASSERT_EQ(AVCS_ERR_UNKNOWN, parserSample->demuxer_->StartReferenceParser(-999999));
88 }
89 
90 /**
91  * @tc.number    : DEMUXER_REFERENCE_H264_API_0020
92  * @tc.name      : StartRefParser with unsupported ts resources
93  * @tc.desc      : api test
94  */
95 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_API_0020, TestSize.Level1)
96 {
97     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
98         return;
99     }
100     auto parserSample = make_unique<InnerDemuxerParserSample>(g_test_file_ts_avc);
101     ASSERT_EQ(AVCS_ERR_UNSUPPORT_FILE_TYPE, parserSample->demuxer_->StartReferenceParser(0));
102 }
103 
104 /**
105  * @tc.number    : DEMUXER_REFERENCE_H264_API_0030
106  * @tc.name      : GetFrameLayerInfo with empty buffer
107  * @tc.desc      : api test
108  */
109 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_API_0030, TestSize.Level1)
110 {
111     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
112         return;
113     }
114     auto parserSample = make_unique<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
115     ASSERT_EQ(AVCS_ERR_OK, parserSample->demuxer_->StartReferenceParser(0));
116     FrameLayerInfo frameLayerInfo;
117     ASSERT_EQ(AVCS_ERR_INVALID_VAL, parserSample->demuxer_->GetFrameLayerInfo(parserSample->avBuffer, frameLayerInfo));
118 }
119 
120 /**
121  * @tc.number    : DEMUXER_REFERENCE_H264_API_0040
122  * @tc.name      : GetFrameLayerInfo with unsupported ts resources
123  * @tc.desc      : api test
124  */
125 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_API_0040, TestSize.Level1)
126 {
127     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
128         return;
129     }
130     auto parserSample = make_unique<InnerDemuxerParserSample>(g_test_file_ts_avc);
131     ASSERT_EQ(AVCS_ERR_UNSUPPORT_FILE_TYPE, parserSample->demuxer_->StartReferenceParser(0));
132     parserSample->InitParameter(MP4Scene::ONE_I_FRAME_AVC);
133     FrameLayerInfo frameLayerInfo;
134     ASSERT_EQ(AVCS_ERR_INVALID_VAL, parserSample->demuxer_->GetFrameLayerInfo(parserSample->avBuffer, frameLayerInfo));
135 }
136 
137 /**
138  * @tc.number    : DEMUXER_REFERENCE_H264_API_0050
139  * @tc.name      : GetGopLayerInfo with error gopID
140  * @tc.desc      : api test
141  */
142 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_API_0050, TestSize.Level1)
143 {
144     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
145         return;
146     }
147     auto parserSample = make_unique<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
148     ASSERT_EQ(AVCS_ERR_OK, parserSample->demuxer_->StartReferenceParser(0));
149     GopLayerInfo gopLayerInfo;
150     ASSERT_EQ(AVCS_ERR_TRY_AGAIN, parserSample->demuxer_->GetGopLayerInfo(99999, gopLayerInfo));
151 }
152 
153 /**
154  * @tc.number    : DEMUXER_REFERENCE_H264_API_0060
155  * @tc.name      : GetFrameLayerInfo with unsupported ts resources
156  * @tc.desc      : api test
157  */
158 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_API_0060, TestSize.Level1)
159 {
160     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
161         return;
162     }
163     auto parserSample = make_unique<InnerDemuxerParserSample>(g_test_file_ts_avc);
164     ASSERT_EQ(AVCS_ERR_UNSUPPORT_FILE_TYPE, parserSample->demuxer_->StartReferenceParser(0));
165     GopLayerInfo gopLayerInfo;
166     ASSERT_EQ(AVCS_ERR_INVALID_VAL, parserSample->demuxer_->GetGopLayerInfo(1, gopLayerInfo));
167 }
168 
169 /**
170  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0010
171  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in an I-frame seek scene
172  * @tc.desc      : func test
173  */
174 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0010, TestSize.Level1)
175 {
176     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
177         return;
178     }
179     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_one_i_frame_avc);
180     parserSample->InitParameter(MP4Scene::ONE_I_FRAME_AVC);
181     parserSample->usleepTime = 1000000;
182     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
183 }
184 
185 /**
186  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0020
187  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in all I-frame seek scene
188  * @tc.desc      : func test
189  */
190 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0020, TestSize.Level1)
191 {
192     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
193         return;
194     }
195     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_all_i_frame_avc);
196     parserSample->InitParameter(MP4Scene::ALL_I_FRAME_AVC);
197     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
198 }
199 
200 /**
201  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0030
202  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in IPB-frame seek scene
203  * @tc.desc      : func test
204  */
205 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0030, TestSize.Level1)
206 {
207     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
208         return;
209     }
210     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ipb_frame_avc);
211     parserSample->InitParameter(MP4Scene::IPB_FRAME_AVC);
212     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
213 }
214 
215 /**
216  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0040
217  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in sdtp-frame seek scene
218  * @tc.desc      : func test
219  */
220 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0040, TestSize.Level1)
221 {
222     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
223         return;
224     }
225     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_sdtp_frame_avc);
226     parserSample->InitParameter(MP4Scene::SDTP_FRAME_AVC);
227     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
228 }
229 
230 /**
231  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0060
232  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in 2-layer-frame seek scene
233  * @tc.desc      : func test
234  */
235 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0060, TestSize.Level1)
236 {
237     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
238         return;
239     }
240     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_2_layer_frame_avc);
241     parserSample->InitParameter(MP4Scene::TWO_LAYER_FRAME_AVC);
242     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
243 }
244 
245 /**
246  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0070
247  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in 4-layer-frame seek scene
248  * @tc.desc      : func test
249  */
250 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0070, TestSize.Level1)
251 {
252     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
253         return;
254     }
255     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_4_layer_frame_avc);
256     parserSample->InitParameter(MP4Scene::FOUR_LAYER_FRAME_AVC);
257     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
258 }
259 
260 /**
261  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0080
262  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in Ltr-frame seek scene
263  * @tc.desc      : func test
264  */
265 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0080, TestSize.Level1)
266 {
267     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
268         return;
269     }
270     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ltr_frame_avc);
271     parserSample->InitParameter(MP4Scene::LTR_FRAME_AVC);
272     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
273 }
274 
275 /**
276  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0090
277  * @tc.name      : Seek forward to the end of the vedio for 1000ms in gop10 fps30 3-layer-frame seek scene
278  * @tc.desc      : func test
279  */
280 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0090, TestSize.Level1)
281 {
282     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
283         return;
284     }
285     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ltr_frame_avc);
286     parserSample->InitParameter(MP4Scene::LTR_FRAME_AVC);
287     for (int64_t i = 0; i < parserSample->duration; i = i + 1000000) {
288         parserSample->specified_pts = i / 1000.0;
289         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::SPECIFIED_PTS));
290     }
291 }
292 
293 /**
294  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0100
295  * @tc.name      : forward to the end,seek backward to the beginning in gop30 fps30 3-layer-frame seek scene
296  * @tc.desc      : func test
297  */
298 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0100, TestSize.Level1)
299 {
300     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
301         return;
302     }
303     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ltr_frame_avc);
304     parserSample->InitParameter(MP4Scene::LTR_FRAME_AVC);
305     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::END_PTS));
306     for (int32_t i = parserSample->duration / 1000.0; i >= 0 ; i = i - 1000) {
307         parserSample->specified_pts = i;
308         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
309     }
310 }
311 
312 /**
313  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0110
314  * @tc.name      : Seek back and forth according to the preset direction and duration in 3-layer-frame seek scene
315  * @tc.desc      : func test
316  */
317 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0110, TestSize.Level1)
318 {
319     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
320         return;
321     }
322     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
323     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_AVC);
324     for (int32_t i = 0; i < 10; i++) {
325         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
326     }
327 }
328 
329 /**
330  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0120
331  * @tc.name      : from the beginning to the end,from the end to the beginning repeat 10 times in 3-layer-frame
332  * @tc.desc      : func test
333  */
334 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0120, TestSize.Level1)
335 {
336     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
337         return;
338     }
339     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
340     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_AVC);
341     for (int32_t i = 0; i < 10; i++) {
342         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::END_PTS));
343         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::START_PTS));
344     }
345 }
346 
347 /**
348  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0130
349  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs is the start position in 3-layer-frame
350  * @tc.desc      : func test
351  */
352 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0130, TestSize.Level1)
353 {
354     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
355         return;
356     }
357     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
358     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_AVC);
359     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::START_PTS));
360 }
361 
362 /**
363  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0140
364  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in gop30 fps30 3-layer-frame seek scene
365  * @tc.desc      : func test
366  */
367 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0140, TestSize.Level1)
368 {
369     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
370         return;
371     }
372     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
373     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_AVC);
374     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
375 }
376 
377 
378 /**
379  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0150
380  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame for startTimeMs in an I
381  * @tc.desc      : func test
382  */
383 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0150, TestSize.Level1)
384 {
385     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
386         return;
387     }
388     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_one_i_frame_avc);
389     parserSample->InitParameter(MP4Scene::ONE_I_FRAME_AVC);
390     parserSample->usleepTime = 1000000;
391     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
392 }
393 
394 /**
395  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0160
396  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame for startTimeMs in all I
397  * @tc.desc      : func test
398  */
399 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0160, TestSize.Level1)
400 {
401     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
402         return;
403     }
404     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_all_i_frame_avc);
405     parserSample->InitParameter(MP4Scene::ALL_I_FRAME_AVC);
406     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
407 }
408 
409 /**
410  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0170
411  * @tc.name      : Pts corresponding to the Nth for startTimeMs=0 in 3-layer-frame double speed play seek scene
412  * @tc.desc      : func test
413  */
414 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0170, TestSize.Level1)
415 {
416     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
417         return;
418     }
419     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
420     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_AVC);
421     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::START_PTS));
422 }
423 
424 /**
425  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0180
426  * @tc.name      : Randomly generating Pts corresponding to the N existing positions for startTimeMs in 3-layer-frame
427  * @tc.desc      : func test
428  */
429 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0180, TestSize.Level1)
430 {
431     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
432         return;
433     }
434     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
435     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_AVC);
436     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
437 }
438 
439 /**
440  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0190
441  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs is the last frame in 3-layer-frame
442  * @tc.desc      : func test
443  */
444 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0190, TestSize.Level1)
445 {
446     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
447         return;
448     }
449     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
450     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_AVC);
451     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::END_PTS));
452 }
453 
454 /**
455  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0200
456  * @tc.name      : Randomly generating Pts corresponding to the N existing positions for startTimeMs in 4-layer-frame
457  * @tc.desc      : func test
458  */
459 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0200, TestSize.Level1)
460 {
461     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
462         return;
463     }
464     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_4_layer_frame_avc);
465     parserSample->InitParameter(MP4Scene::FOUR_LAYER_FRAME_AVC);
466     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
467 }
468 
469 /**
470  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0210
471  * @tc.name      : Randomly generating Pts corresponding to the N existing positions for startTimeMs in 2-layer-frame
472  * @tc.desc      : func test
473  */
474 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0210, TestSize.Level1)
475 {
476     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
477         return;
478     }
479     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_2_layer_frame_avc);
480     parserSample->InitParameter(MP4Scene::TWO_LAYER_FRAME_AVC);
481     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
482 }
483 
484 /**
485  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0220
486  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame for startTimeMs in Ltr-frame
487  * @tc.desc      : func test
488  */
489 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0220, TestSize.Level1)
490 {
491     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
492         return;
493     }
494     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ltr_frame_avc);
495     parserSample->InitParameter(MP4Scene::LTR_FRAME_AVC);
496     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
497 }
498 
499 /**
500  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0230
501  * @tc.name      : Randomly generating Pts corresponding to the N existing positions for startTimeMs in gop30 IPB
502  * @tc.desc      : func test
503  */
504 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0230, TestSize.Level1)
505 {
506     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
507         return;
508     }
509     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ipb_frame_avc);
510     parserSample->InitParameter(MP4Scene::IPB_FRAME_AVC);
511     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
512 }
513 
514 /**
515  * @tc.number    : DEMUXER_REFERENCE_H264_FUNC_0240
516  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame for startTimeMs in sdtp
517  * @tc.desc      : func test
518  */
519 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H264_FUNC_0240, TestSize.Level1)
520 {
521     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
522         return;
523     }
524     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_sdtp_frame_avc);
525     parserSample->InitParameter(MP4Scene::SDTP_FRAME_AVC);
526     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
527 }
528 
529 /**
530  * @tc.number    : DEMUXER_REFERENCE_H265_API_0010
531  * @tc.name      : StartRefParser with non-existent pts
532  * @tc.desc      : api test
533  */
534 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_API_0010, TestSize.Level1)
535 {
536     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
537         return;
538     }
539     auto parserSample = make_unique<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
540     ASSERT_EQ(AVCS_ERR_UNKNOWN, parserSample->demuxer_->StartReferenceParser(-999999));
541 }
542 
543 /**
544  * @tc.number    : DEMUXER_REFERENCE_H265_API_0020
545  * @tc.name      : StartRefParser with unsupported ts resources
546  * @tc.desc      : api test
547  */
548 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_API_0020, TestSize.Level1)
549 {
550     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
551         return;
552     }
553     auto parserSample = make_unique<InnerDemuxerParserSample>(g_test_file_ts_hevc);
554     ASSERT_EQ(AVCS_ERR_UNSUPPORT_FILE_TYPE, parserSample->demuxer_->StartReferenceParser(0));
555 }
556 
557 /**
558  * @tc.number    : DEMUXER_REFERENCE_H265_API_0030
559  * @tc.name      : GetFrameLayerInfo with empty buffer
560  * @tc.desc      : api test
561  */
562 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_API_0030, TestSize.Level1)
563 {
564     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
565         return;
566     }
567     auto parserSample = make_unique<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
568     ASSERT_EQ(AVCS_ERR_OK, parserSample->demuxer_->StartReferenceParser(0));
569     FrameLayerInfo frameLayerInfo;
570     ASSERT_EQ(AVCS_ERR_INVALID_VAL, parserSample->demuxer_->GetFrameLayerInfo(parserSample->avBuffer, frameLayerInfo));
571 }
572 
573 /**
574  * @tc.number    : DEMUXER_REFERENCE_H265_API_0040
575  * @tc.name      : GetFrameLayerInfo with unsupported ts resources
576  * @tc.desc      : api test
577  */
578 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_API_0040, TestSize.Level1)
579 {
580     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
581         return;
582     }
583     auto parserSample = make_unique<InnerDemuxerParserSample>(g_test_file_ts_hevc);
584     ASSERT_EQ(AVCS_ERR_UNSUPPORT_FILE_TYPE, parserSample->demuxer_->StartReferenceParser(0));
585     parserSample->InitParameter(MP4Scene::ONE_I_FRAME_HEVC);
586     FrameLayerInfo frameLayerInfo;
587     ASSERT_EQ(AVCS_ERR_INVALID_VAL, parserSample->demuxer_->GetFrameLayerInfo(parserSample->avBuffer, frameLayerInfo));
588 }
589 
590 /**
591  * @tc.number    : DEMUXER_REFERENCE_H265_API_0050
592  * @tc.name      : GetGopLayerInfo with error gopID
593  * @tc.desc      : api test
594  */
595 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_API_0050, TestSize.Level1)
596 {
597     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
598         return;
599     }
600     auto parserSample = make_unique<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
601     ASSERT_EQ(AVCS_ERR_OK, parserSample->demuxer_->StartReferenceParser(0));
602     GopLayerInfo gopLayerInfo;
603     ASSERT_EQ(AVCS_ERR_TRY_AGAIN, parserSample->demuxer_->GetGopLayerInfo(99999, gopLayerInfo));
604 }
605 
606 /**
607  * @tc.number    : DEMUXER_REFERENCE_H265_API_0060
608  * @tc.name      : GetFrameLayerInfo with unsupported ts resources
609  * @tc.desc      : api test
610  */
611 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_API_0060, TestSize.Level1)
612 {
613     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
614         return;
615     }
616     auto parserSample = make_unique<InnerDemuxerParserSample>(g_test_file_ts_hevc);
617     ASSERT_EQ(AVCS_ERR_UNSUPPORT_FILE_TYPE, parserSample->demuxer_->StartReferenceParser(0));
618     GopLayerInfo gopLayerInfo;
619     ASSERT_EQ(AVCS_ERR_INVALID_VAL, parserSample->demuxer_->GetGopLayerInfo(1, gopLayerInfo));
620 }
621 
622 /**
623  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0010
624  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in an I-frame seek scene
625  * @tc.desc      : func test
626  */
627 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0010, TestSize.Level1)
628 {
629     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
630         return;
631     }
632     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_one_i_frame_hevc);
633     parserSample->InitParameter(MP4Scene::ONE_I_FRAME_HEVC);
634     parserSample->usleepTime = 1000000;
635     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
636 }
637 
638 /**
639  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0020
640  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in all I-frame seek scene
641  * @tc.desc      : func test
642  */
643 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0020, TestSize.Level1)
644 {
645     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
646         return;
647     }
648     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_all_i_frame_hevc);
649     parserSample->InitParameter(MP4Scene::ALL_I_FRAME_HEVC);
650     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
651 }
652 
653 /**
654  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0030
655  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in IPB-frame seek scene
656  * @tc.desc      : func test
657  */
658 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0030, TestSize.Level1)
659 {
660     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
661         return;
662     }
663     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ipb_frame_hevc);
664     parserSample->InitParameter(MP4Scene::IPB_FRAME_HEVC);
665     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
666 }
667 
668 /**
669  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0040
670  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in sdtp-frame seek scene
671  * @tc.desc      : func test
672  */
673 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0040, TestSize.Level1)
674 {
675     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
676         return;
677     }
678     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_sdtp_frame_hevc);
679     parserSample->InitParameter(MP4Scene::SDTP_FRAME_HEVC);
680     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
681 }
682 
683 /**
684  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0050
685  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in sdtp-extended seek scene
686  * @tc.desc      : func test
687  */
688 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0050, TestSize.Level1)
689 {
690     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
691         return;
692     }
693     shared_ptr<InnerDemuxerParserSample> parserSample =
694         make_shared<InnerDemuxerParserSample>(g_file_sdtp_extended_hevc);
695     parserSample->InitParameter(MP4Scene::SDTP_EXTENDED_HEVC);
696     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
697 }
698 
699 /**
700  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0060
701  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in 2-layer-frame seek scene
702  * @tc.desc      : func test
703  */
704 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0060, TestSize.Level1)
705 {
706     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
707         return;
708     }
709     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
710     parserSample = make_shared<InnerDemuxerParserSample>(g_file_2_layer_frame_hevc);
711     parserSample->InitParameter(MP4Scene::TWO_LAYER_FRAME_HEVC);
712     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
713 }
714 
715 /**
716  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0070
717  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in 4-layer-frame seek scene
718  * @tc.desc      : func test
719  */
720 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0070, TestSize.Level1)
721 {
722     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
723         return;
724     }
725     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
726     parserSample = make_shared<InnerDemuxerParserSample>(g_file_4_layer_frame_hevc);
727     parserSample->InitParameter(MP4Scene::FOUR_LAYER_FRAME_HEVC);
728     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
729 }
730 
731 /**
732  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0080
733  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in Ltr-frame seek scene
734  * @tc.desc      : func test
735  */
736 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0080, TestSize.Level1)
737 {
738     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
739         return;
740     }
741     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ltr_frame_hevc);
742     parserSample->InitParameter(MP4Scene::LTR_FRAME_HEVC);
743     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
744 }
745 
746 /**
747  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0090
748  * @tc.name      : Seek forward to the end of the vedio for 1000ms in gop10 fps30 3-layer-frame seek scene
749  * @tc.desc      : func test
750  */
751 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0090, TestSize.Level1)
752 {
753     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
754         return;
755     }
756     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ltr_frame_hevc);
757     parserSample->InitParameter(MP4Scene::LTR_FRAME_HEVC);
758     for (int64_t i = 0; i < parserSample->duration; i = i + 1000000) {
759         parserSample->specified_pts = i / 1000.0;
760         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::SPECIFIED_PTS));
761     }
762 }
763 
764 /**
765  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0100
766  * @tc.name      : Seek to the end,then backward to the beginning for 1000ms in gop30 fps30 3-layer-frame seek scene
767  * @tc.desc      : func test
768  */
769 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0100, TestSize.Level1)
770 {
771     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
772         return;
773     }
774     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ltr_frame_hevc);
775     parserSample->InitParameter(MP4Scene::LTR_FRAME_HEVC);
776     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::END_PTS));
777     for (int32_t i = parserSample->duration / 1000.0; i >= 0 ; i = i - 1000) {
778         parserSample->specified_pts = i;
779         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
780     }
781 }
782 
783 /**
784  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0110
785  * @tc.name      : Seek back and forth according to the preset direction and duration in gop60 fps30 3-layer-frame
786  * @tc.desc      : func test
787  */
788 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0110, TestSize.Level1)
789 {
790     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
791         return;
792     }
793     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
794     parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
795     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_HEVC);
796     for (int32_t i = 0; i < 10; i++) {
797         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
798     }
799 }
800 
801 /**
802  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0120
803  * @tc.name      : from the beginning to the end and from the end to the beginning repeat 10 times in 3-layer-frame
804  * @tc.desc      : func test
805  */
806 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0120, TestSize.Level1)
807 {
808     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
809         return;
810     }
811     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
812     parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
813     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_HEVC);
814     for (int32_t i = 0; i < 10; i++) {
815         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::END_PTS));
816         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::START_PTS));
817     }
818 }
819 
820 /**
821  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0130
822  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs is the start position in 3-layer-frame
823  * @tc.desc      : func test
824  */
825 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0130, TestSize.Level1)
826 {
827     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
828         return;
829     }
830     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
831     parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
832     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_HEVC);
833     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::START_PTS));
834 }
835 
836 /**
837  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0140
838  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in gop30 fps30 3-layer-frame seek scene
839  * @tc.desc      : func test
840  */
841 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0140, TestSize.Level1)
842 {
843     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
844         return;
845     }
846     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
847     parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
848     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_HEVC);
849     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
850 }
851 
852 
853 /**
854  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0150
855  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame for startTimeMs in an I
856  * @tc.desc      : func test
857  */
858 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0150, TestSize.Level1)
859 {
860     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
861         return;
862     }
863     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_one_i_frame_hevc);
864     parserSample->InitParameter(MP4Scene::ONE_I_FRAME_HEVC);
865     parserSample->usleepTime = 1000000;
866     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
867 }
868 
869 /**
870  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0160
871  * @tc.name      : Randomly generating Pts corresponding to the N existing positions for startTimeMs in all I-frame
872  * @tc.desc      : func test
873  */
874 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0160, TestSize.Level1)
875 {
876     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
877         return;
878     }
879     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_all_i_frame_hevc);
880     parserSample->InitParameter(MP4Scene::ALL_I_FRAME_HEVC);
881     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
882 }
883 
884 /**
885  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0170
886  * @tc.name      : Pts corresponding to the Nth for startTimeMs=0 in 3-layer-frame double speed play seek scene
887  * @tc.desc      : func test
888  */
889 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0170, TestSize.Level1)
890 {
891     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
892         return;
893     }
894     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
895     parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
896     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_HEVC);
897     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::START_PTS));
898 }
899 
900 /**
901  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0180
902  * @tc.name      : Randomly generating Pts corresponding to the N existing positions for startTimeMs in 3-layer-frame
903  * @tc.desc      : func test
904  */
905 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0180, TestSize.Level1)
906 {
907     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
908         return;
909     }
910     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
911     parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
912     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_HEVC);
913     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
914 }
915 
916 /**
917  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0190
918  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs is the last frame in 3-layer-frame
919  * @tc.desc      : func test
920  */
921 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0190, TestSize.Level1)
922 {
923     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
924         return;
925     }
926     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
927     parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_hevc);
928     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_HEVC);
929     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::END_PTS));
930 }
931 
932 /**
933  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0200
934  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame in 4-layer-frame
935  * @tc.desc      : func test
936  */
937 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0200, TestSize.Level1)
938 {
939     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
940         return;
941     }
942     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
943     parserSample = make_shared<InnerDemuxerParserSample>(g_file_4_layer_frame_hevc);
944     parserSample->InitParameter(MP4Scene::FOUR_LAYER_FRAME_HEVC);
945     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
946 }
947 
948 /**
949  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0210
950  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame in 2-layer-frame
951  * @tc.desc      : func test
952  */
953 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0210, TestSize.Level1)
954 {
955     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
956         return;
957     }
958     shared_ptr<InnerDemuxerParserSample> parserSample = nullptr;
959     parserSample = make_shared<InnerDemuxerParserSample>(g_file_2_layer_frame_hevc);
960     parserSample->InitParameter(MP4Scene::TWO_LAYER_FRAME_HEVC);
961     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
962 }
963 
964 /**
965  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0220
966  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame in Ltr-frame
967  * @tc.desc      : func test
968  */
969 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0220, TestSize.Level1)
970 {
971     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
972         return;
973     }
974     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ltr_frame_hevc);
975     parserSample->InitParameter(MP4Scene::LTR_FRAME_HEVC);
976     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
977 }
978 
979 /**
980  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0230
981  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame in gop30 IPB-frame
982  * @tc.desc      : func test
983  */
984 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0230, TestSize.Level1)
985 {
986     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
987         return;
988     }
989     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_ipb_frame_hevc);
990     parserSample->InitParameter(MP4Scene::IPB_FRAME_HEVC);
991     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
992 }
993 
994 /**
995  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0240
996  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame in sdtp-frame
997  * @tc.desc      : func test
998  */
999 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0240, TestSize.Level1)
1000 {
1001     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1002         return;
1003     }
1004     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_sdtp_frame_hevc);
1005     parserSample->InitParameter(MP4Scene::SDTP_FRAME_HEVC);
1006     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
1007 }
1008 
1009 /**
1010  * @tc.number    : DEMUXER_REFERENCE_H265_FUNC_0250
1011  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame in sdtp-extended
1012  * @tc.desc      : func test
1013  */
1014 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_H265_FUNC_0250, TestSize.Level1)
1015 {
1016     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1017         return;
1018     }
1019     shared_ptr<InnerDemuxerParserSample> parserSample =
1020         make_shared<InnerDemuxerParserSample>(g_file_sdtp_extended_hevc);
1021     parserSample->InitParameter(MP4Scene::SDTP_EXTENDED_HEVC);
1022     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
1023 }
1024 
1025 /**
1026  * @tc.number    : DEMUXER_REFERENCE_HDR_0010
1027  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in HDR sequence seek scene
1028  * @tc.desc      : func test
1029  */
1030 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_HDR_0010, TestSize.Level1)
1031 {
1032     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1033         return;
1034     }
1035     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_hdr_1_hevc);
1036     parserSample->InitParameter(MP4Scene::HDR_1_HEVC);
1037     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::END_PTS));
1038 }
1039 
1040 /**
1041  * @tc.number    : DEMUXER_REFERENCE_HDR_0020
1042  * @tc.name      : Pts corresponding to the Nth frame for startTimeMs in HDR sequence seek scene
1043  * @tc.desc      : func test
1044  */
1045 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_HDR_0020, TestSize.Level1)
1046 {
1047     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1048         return;
1049     }
1050     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_hdr_2_hevc);
1051     parserSample->InitParameter(MP4Scene::HDR_2_HEVC);
1052     ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
1053 }
1054 
1055 /**
1056  * @tc.number    : DEMUXER_REFERENCE_HDR_0021
1057  * @tc.name      : Randomly generating Pts corresponding to the N existing positions frame in HDR sequence
1058  * @tc.desc      : func test
1059  */
1060 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_HDR_0021, TestSize.Level1)
1061 {
1062     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1063         return;
1064     }
1065     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_hdr_2_hevc);
1066     parserSample->InitParameter(MP4Scene::HDR_2_HEVC);
1067     ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::RANDOM_PTS));
1068 }
1069 
1070 HWTEST_F(InnerParsercNdkTest, DEMUXER_REFERENCE_RELI_0010, TestSize.Level3)
1071 {
1072     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
1073         return;
1074     }
1075     shared_ptr<InnerDemuxerParserSample> parserSample = make_shared<InnerDemuxerParserSample>(g_file_3_layer_frame_avc);
1076     parserSample->InitParameter(MP4Scene::THREE_LAYER_FRAME_AVC);
1077     for (int i = 0; i < 10; i++) {
1078         ASSERT_TRUE(parserSample->RunSeekScene(WorkPts::RANDOM_PTS));
1079     }
1080     for (int i = 0; i < 10; i++) {
1081         ASSERT_TRUE(parserSample->RunSpeedScene(WorkPts::START_PTS));
1082     }
1083 }
1084 
1085 } // namespace