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