1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "avdemuxer.h"
19 #include "avsource.h"
20 #include "meta/format.h"
21 #include "avcodec_errors.h"
22 #include "avcodec_common.h"
23 #include "buffer/avsharedmemory.h"
24 #include "buffer/avsharedmemorybase.h"
25 #include "securec.h"
26 #include "inner_demuxer_sample.h"
27
28 #include "common/status.h"
29 #include "avdemuxer.h"
30
31 #include <iostream>
32 #include <cstdio>
33 #include <string>
34 #include <fcntl.h>
35
36 using namespace std;
37 using namespace OHOS;
38 using namespace OHOS::MediaAVCodec;
39 using namespace OHOS::Media;
40 using namespace testing::ext;
41
42 namespace {
43 class DemuxerCacheFuncNdkTest : public testing::Test {
44 public:
45 // SetUpTestCase: Called before all test cases
46 static void SetUpTestCase(void);
47 // TearDownTestCase: Called after all test case
48 static void TearDownTestCase(void);
49 // SetUp: Called before each test cases
50 void SetUp(void);
51 // TearDown: Called after each test cases
52 void TearDown(void);
53 };
54
SetUpTestCase()55 void DemuxerCacheFuncNdkTest::SetUpTestCase() {}
TearDownTestCase()56 void DemuxerCacheFuncNdkTest::TearDownTestCase() {}
SetUp()57 void DemuxerCacheFuncNdkTest::SetUp() {}
TearDown()58 void DemuxerCacheFuncNdkTest::TearDown() {}
59 } // namespace
60
61 namespace {
62 /**
63 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0010
64 * @tc.name : No track ID is selected
65 * @tc.desc : func test
66 */
67 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0010, TestSize.Level1)
68 {
69 auto demuxerSample = make_unique<InnerDemuxerSample>();
70 demuxerSample->indexVid = 0;
71 demuxerSample->unSelectTrack = 0;
72 uint32_t memoryUsage = 0;
73 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/audio/gb2312.mp3", true), AVCS_ERR_OK);
74 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
75 ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, demuxerSample->demuxer_->GetCurrentCacheSize(
76 demuxerSample->unSelectTrack, memoryUsage));
77 }
78
79 /**
80 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0020
81 * @tc.name : The entered track ID is not selected
82 * @tc.desc : func test
83 */
84 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0020, TestSize.Level1)
85 {
86 auto demuxerSample = make_unique<InnerDemuxerSample>();
87 demuxerSample->indexVid = 0;
88 demuxerSample->unSelectTrack = 2;
89 uint32_t memoryUsage = 0;
90 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
91 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
92 ASSERT_EQ(AVCS_ERR_INVALID_VAL, demuxerSample->demuxer_->GetCurrentCacheSize(
93 demuxerSample->unSelectTrack, memoryUsage));
94 }
95
96 /**
97 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0030
98 * @tc.name : mp4(1video+1audio+1subtitle), Read the video track at the beginning stage
99 * @tc.desc : func test
100 */
101 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0030, TestSize.Level1)
102 {
103 auto demuxerSample = make_unique<InnerDemuxerSample>();
104 demuxerSample->readPos = 2;
105 demuxerSample->indexVid = 0;
106 demuxerSample->indexAud = 1;
107 demuxerSample->indexSub = 2;
108 std::vector<std::vector<int32_t>> cacheCheckSteps = {
109 {0, 0, 0, 0},
110 {1, 218, 0, 0},
111 {2, 2, 2, 0},
112 };
113 int32_t readCount = 0;
114 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
115 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
116 while (true)
117 {
118 if (readCount >= demuxerSample->readPos)
119 {
120 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
121 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
122 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
123 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
124 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
125 break;
126 } else {
127 readCount++;
128 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
129 }
130 }
131 }
132
133 /**
134 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0040
135 * @tc.name : mp4(1video+1audio+1subtitle), Read the video track in the middle stage
136 * @tc.desc : func test
137 */
138 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0040, TestSize.Level1)
139 {
140 auto demuxerSample = make_unique<InnerDemuxerSample>();
141 demuxerSample->readPos = 326;
142 demuxerSample->indexVid = 0;
143 demuxerSample->indexAud = 1;
144 demuxerSample->indexSub = 2;
145 std::vector<std::vector<int32_t>> cacheCheckSteps = {
146 {0, 0, 0, 0},
147 {1, 43671, 43453, 43453},
148 {2, 8, 8, 6},
149 };
150 int32_t readCount = 0;
151 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
152 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
153 while (true)
154 {
155 if (readCount >= demuxerSample->readPos)
156 {
157 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
158 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
159 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
160 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
161 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
162 break;
163 } else {
164 readCount++;
165 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
166 }
167 }
168 }
169
170 /**
171 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0050
172 * @tc.name : mp4(1video+1audio+1subtitle), Read the video track at the final stage
173 * @tc.desc : func test
174 */
175 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0050, TestSize.Level1)
176 {
177 auto demuxerSample = make_unique<InnerDemuxerSample>();
178 demuxerSample->readPos = 600;
179 demuxerSample->indexVid = 0;
180 demuxerSample->indexAud = 1;
181 demuxerSample->indexSub = 2;
182 std::vector<std::vector<int32_t>> cacheCheckSteps = {
183 {0, 0, 0, 0},
184 {1, 80225, 80007, 80007},
185 {2, 14, 14, 12},
186 };
187 int32_t readCount = 0;
188 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
189 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
190 while (true)
191 {
192 if (readCount >= demuxerSample->readPos)
193 {
194 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
195 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
196 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
197 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
198 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
199 break;
200 } else {
201 readCount++;
202 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
203 }
204 }
205 }
206
207 /**
208 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0060
209 * @tc.name : mp4(1video+1audio+1subtitle), Read the audio track at the beginning stage
210 * @tc.desc : func test
211 */
212 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0060, TestSize.Level1)
213 {
214 auto demuxerSample = make_unique<InnerDemuxerSample>();
215 demuxerSample->readPos = 2;
216 demuxerSample->indexVid = 0;
217 demuxerSample->indexAud = 1;
218 demuxerSample->indexSub = 2;
219 std::vector<std::vector<int32_t>> cacheCheckSteps = {
220 {0, 29661, 9197, 9197},
221 {1, 0, 0, 0},
222 {2, 2, 2, 0},
223 };
224 int32_t readCount = 0;
225 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
226 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
227 while (true)
228 {
229 if (readCount >= demuxerSample->readPos)
230 {
231 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
232 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
233 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
234 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
235 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
236 break;
237 } else {
238 readCount++;
239 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
240 }
241 }
242 }
243
244 /**
245 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0070
246 * @tc.name : mp4(1video+1audio+1subtitle), Read the audio track in the middle stage
247 * @tc.desc : func test
248 */
249 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0070, TestSize.Level1)
250 {
251 auto demuxerSample = make_unique<InnerDemuxerSample>();
252 demuxerSample->readPos = 326;
253 demuxerSample->indexVid = 0;
254 demuxerSample->indexAud = 1;
255 demuxerSample->indexSub = 2;
256 std::vector<std::vector<int32_t>> cacheCheckSteps = {
257 {0, 4261461, 4240997, 4240997},
258 {1, 0, 0, 0},
259 {2, 11, 11, 9},
260 };
261 int32_t readCount = 0;
262 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
263 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
264 while (true)
265 {
266 if (readCount >= demuxerSample->readPos)
267 {
268 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
269 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
270 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
271 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
272 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
273 break;
274 } else {
275 readCount++;
276 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
277 }
278 }
279 }
280
281 /**
282 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0080
283 * @tc.name : mp4(1video+1audio+1subtitle), Read the audio track at the final stage
284 * @tc.desc : func test
285 */
286 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0080, TestSize.Level1)
287 {
288 auto demuxerSample = make_unique<InnerDemuxerSample>();
289 demuxerSample->readPos = 430;
290 demuxerSample->indexVid = 0;
291 demuxerSample->indexAud = 1;
292 demuxerSample->indexSub = 2;
293 std::vector<std::vector<int32_t>> cacheCheckSteps = {
294 {0, 5462115, 5441651, 5441651},
295 {1, 0, 0, 0},
296 {2, 14, 14, 12},
297 };
298 int32_t readCount = 0;
299 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
300 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
301 while (true)
302 {
303 if (readCount >= demuxerSample->readPos)
304 {
305 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
306 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
307 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
308 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
309 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
310 break;
311 } else {
312 readCount++;
313 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
314 }
315 }
316 }
317
318 /**
319 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0090
320 * @tc.name : mp4(1video+1audio+1subtitle), Read the subtitle track at the beginning stage
321 * @tc.desc : func test
322 */
323 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0090, TestSize.Level1)
324 {
325 auto demuxerSample = make_unique<InnerDemuxerSample>();
326 demuxerSample->readPos = 2;
327 demuxerSample->indexVid = 0;
328 demuxerSample->indexAud = 1;
329 demuxerSample->indexSub = 2;
330 std::vector<std::vector<int32_t>> cacheCheckSteps = {
331 {0, 655777, 635313, 635313},
332 {1, 8214, 8214, 7996},
333 {2, 0, 0, 0},
334 };
335 int32_t readCount = 0;
336 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
337 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
338 while (true)
339 {
340 if (readCount >= demuxerSample->readPos)
341 {
342 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
343 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
344 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
345 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
346 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
347 break;
348 } else {
349 readCount++;
350 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
351 }
352 }
353 }
354
355 /**
356 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0100
357 * @tc.name : mp4(1video+1audio+1subtitle), Read the subtitle track in the middle stage
358 * @tc.desc : func test
359 */
360 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0100, TestSize.Level1)
361 {
362 auto demuxerSample = make_unique<InnerDemuxerSample>();
363 demuxerSample->readPos = 4;
364 demuxerSample->indexVid = 0;
365 demuxerSample->indexAud = 1;
366 demuxerSample->indexSub = 2;
367 std::vector<std::vector<int32_t>> cacheCheckSteps = {
368 {0, 4197109, 4176645, 4176645},
369 {1, 59519, 59519, 59301},
370 {2, 0, 0, 0},
371 };
372 int32_t readCount = 0;
373 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
374 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
375 while (true)
376 {
377 if (readCount >= demuxerSample->readPos)
378 {
379 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
380 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
381 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
382 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
383 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
384 break;
385 } else {
386 readCount++;
387 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
388 }
389 }
390 }
391
392 /**
393 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0110
394 * @tc.name : mp4(1video+1audio+1subtitle), Read the subtitle track at the final stage
395 * @tc.desc : func test
396 */
397 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0110, TestSize.Level1)
398 {
399 auto demuxerSample = make_unique<InnerDemuxerSample>();
400 demuxerSample->readPos = 12;
401 demuxerSample->indexVid = 0;
402 demuxerSample->indexAud = 1;
403 demuxerSample->indexSub = 2;
404 std::vector<std::vector<int32_t>> cacheCheckSteps = {
405 {0, 5476556, 5456092, 5456092},
406 {1, 80412, 80412, 80194},
407 {2, 0, 0, 0},
408 };
409 int32_t readCount = 0;
410 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/sub_video_audio.mp4", true), AVCS_ERR_OK);
411 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
412 while (true)
413 {
414 if (readCount >= demuxerSample->readPos)
415 {
416 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
417 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
418 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
419 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
420 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
421 break;
422 } else {
423 readCount++;
424 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexSub, demuxerSample->avBuffer);
425 }
426 }
427 }
428
429 /**
430 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0120
431 * @tc.name : mp4(1video+1audio+1meta), Read the video track at the beginning stage
432 * @tc.desc : func test
433 */
434 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0120, TestSize.Level1)
435 {
436 auto demuxerSample = make_unique<InnerDemuxerSample>();
437 demuxerSample->readPos = 2;
438 demuxerSample->indexVid = 1;
439 demuxerSample->indexAud = 2;
440 demuxerSample->indexData = 0;
441 std::vector<std::vector<int32_t>> cacheCheckSteps = {
442 {0, 61765, 61765, 0},
443 {1, 0, 0, 0},
444 {2, 15, 0, 0},
445 };
446 int32_t readCount = 0;
447 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
448 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
449 while (true)
450 {
451 if (readCount >= demuxerSample->readPos)
452 {
453 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
454 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
455 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
456 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
457 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
458 break;
459 } else {
460 readCount++;
461 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
462 }
463 }
464 }
465
466 /**
467 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0130
468 * @tc.name : mp4(1video+1audio+1meta), Read the video track in the middle stage
469 * @tc.desc : func test
470 */
471 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0130, TestSize.Level1)
472 {
473 auto demuxerSample = make_unique<InnerDemuxerSample>();
474 demuxerSample->readPos = 100;
475 demuxerSample->indexVid = 1;
476 demuxerSample->indexAud = 2;
477 demuxerSample->indexData = 0;
478 std::vector<std::vector<int32_t>> cacheCheckSteps = {
479 {0, 9711576, 9711576, 9649811},
480 {1, 0, 0, 0},
481 {2, 37428, 37413, 37413},
482 };
483 int32_t readCount = 0;
484 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
485 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
486 while (true)
487 {
488 if (readCount >= demuxerSample->readPos)
489 {
490 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
491 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
492 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
493 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
494 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
495 break;
496 } else {
497 readCount++;
498 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
499 }
500 }
501 }
502
503 /**
504 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0140
505 * @tc.name : mp4(1video+1audio+1meta), Read the video track at the final stage
506 * @tc.desc : func test
507 */
508 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0140, TestSize.Level1)
509 {
510 auto demuxerSample = make_unique<InnerDemuxerSample>();
511 demuxerSample->readPos = 210;
512 demuxerSample->indexVid = 1;
513 demuxerSample->indexAud = 2;
514 demuxerSample->indexData = 0;
515 std::vector<std::vector<int32_t>> cacheCheckSteps = {
516 {0, 9711576, 9711576, 9649811},
517 {1, 0, 0, 0},
518 {2, 79252, 79237, 79237},
519 };
520 int32_t readCount = 0;
521 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
522 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
523 while (true)
524 {
525 if (readCount >= demuxerSample->readPos)
526 {
527 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
528 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
529 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
530 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
531 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
532 break;
533 } else {
534 readCount++;
535 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
536 }
537 }
538 }
539
540 /**
541 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0150
542 * @tc.name : mp4(1video+1audio+1meta), Read the audio track at the beginning stage
543 * @tc.desc : func test
544 */
545 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0150, TestSize.Level1)
546 {
547 auto demuxerSample = make_unique<InnerDemuxerSample>();
548 demuxerSample->readPos = 2;
549 demuxerSample->indexVid = 1;
550 demuxerSample->indexAud = 2;
551 demuxerSample->indexData = 0;
552 std::vector<std::vector<int32_t>> cacheCheckSteps = {
553 {0, 97145, 97145, 35380},
554 {1, 97147, 35381, 35381},
555 {2, 0, 0, 0},
556 };
557 int32_t readCount = 0;
558 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
559 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
560 while (true)
561 {
562 if (readCount >= demuxerSample->readPos)
563 {
564 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
565 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
566 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
567 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
568 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
569 break;
570 } else {
571 readCount++;
572 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
573 }
574 }
575 }
576
577 /**
578 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0160
579 * @tc.name : mp4(1video+1audio+1meta), Read the audio track in the middle stage
580 * @tc.desc : func test
581 */
582 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0160, TestSize.Level1)
583 {
584 auto demuxerSample = make_unique<InnerDemuxerSample>();
585 demuxerSample->readPos = 100;
586 demuxerSample->indexVid = 1;
587 demuxerSample->indexAud = 2;
588 demuxerSample->indexData = 0;
589 std::vector<std::vector<int32_t>> cacheCheckSteps = {
590 {0, 9711576, 9711576, 9649811},
591 {1, 4618815, 4557049, 4557049},
592 {2, 0, 0, 0},
593 };
594 int32_t readCount = 0;
595 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
596 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
597 while (true)
598 {
599 if (readCount >= demuxerSample->readPos)
600 {
601 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
602 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
603 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
604 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
605 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
606 break;
607 } else {
608 readCount++;
609 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
610 }
611 }
612 }
613
614 /**
615 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0170
616 * @tc.name : mp4(1video+1audio+1meta), Read the audio track at the final stage
617 * @tc.desc : func test
618 */
619 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0170, TestSize.Level1)
620 {
621 auto demuxerSample = make_unique<InnerDemuxerSample>();
622 demuxerSample->readPos = 211;
623 demuxerSample->indexVid = 1;
624 demuxerSample->indexAud = 2;
625 demuxerSample->indexData = 0;
626 std::vector<std::vector<int32_t>> cacheCheckSteps = {
627 {0, 9711576, 9711576, 9649811},
628 {1, 8320000, 8258234, 8258234},
629 {2, 0, 0, 0},
630 };
631 int32_t readCount = 0;
632 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
633 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
634 while (true)
635 {
636 if (readCount >= demuxerSample->readPos)
637 {
638 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
639 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
640 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
641 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
642 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
643 break;
644 } else {
645 readCount++;
646 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
647 }
648 }
649 }
650
651 /**
652 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0180
653 * @tc.name : mp4(1video+1audio+1meta), Read the meta track at the beginning stage
654 * @tc.desc : func test
655 */
656 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0180, TestSize.Level1)
657 {
658 auto demuxerSample = make_unique<InnerDemuxerSample>();
659 demuxerSample->readPos = 2;
660 demuxerSample->indexVid = 1;
661 demuxerSample->indexAud = 2;
662 demuxerSample->indexData = 0;
663 std::vector<std::vector<int32_t>> cacheCheckSteps = {
664 {0, 0, 0, 0},
665 {1, 97147, 35381, 35381},
666 {2, 15, 15, 0},
667 };
668 int32_t readCount = 0;
669 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
670 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
671 while (true)
672 {
673 if (readCount >= demuxerSample->readPos)
674 {
675 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
676 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
677 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
678 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
679 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
680 break;
681 } else {
682 readCount++;
683 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
684 }
685 }
686 }
687
688 /**
689 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0190
690 * @tc.name : mp4(1video+1audio+1meta), Read the meta track in the middle stage
691 * @tc.desc : func test
692 */
693 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0190, TestSize.Level1)
694 {
695 auto demuxerSample = make_unique<InnerDemuxerSample>();
696 demuxerSample->readPos = 100;
697 demuxerSample->indexVid = 1;
698 demuxerSample->indexAud = 2;
699 demuxerSample->indexData = 0;
700 std::vector<std::vector<int32_t>> cacheCheckSteps = {
701 {0, 0, 0, 0},
702 {1, 1463038, 1401272, 1401272},
703 {2, 16526, 16526, 16511},
704 };
705 int32_t readCount = 0;
706 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
707 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
708 while (true)
709 {
710 if (readCount >= demuxerSample->readPos)
711 {
712 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
713 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
714 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
715 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
716 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
717 break;
718 } else {
719 readCount++;
720 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
721 }
722 }
723 }
724
725 /**
726 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0200
727 * @tc.name : mp4(1video+1audio+1meta), Read the meta track at the final stage
728 * @tc.desc : func test
729 */
730 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0200, TestSize.Level1)
731 {
732 auto demuxerSample = make_unique<InnerDemuxerSample>();
733 demuxerSample->readPos = 210;
734 demuxerSample->indexVid = 1;
735 demuxerSample->indexAud = 2;
736 demuxerSample->indexData = 0;
737 std::vector<std::vector<int32_t>> cacheCheckSteps = {
738 {0, 0, 0, 0},
739 {1, 1502812, 1441046, 1441046},
740 {2, 17247, 17247, 17232},
741 };
742 int32_t readCount = 0;
743 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/Timedmetadata1Track0.mp4", true), AVCS_ERR_OK);
744 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
745 while (true)
746 {
747 if (readCount >= demuxerSample->readPos)
748 {
749 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
750 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexVid, demuxerSample->avBuffer);
751 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 2));
752 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
753 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 3));
754 break;
755 } else {
756 readCount++;
757 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexData, demuxerSample->avBuffer);
758 }
759 }
760 }
761
762 /**
763 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0210
764 * @tc.name : mp4(1video+9audio), Read the video track at the beginning stage
765 * @tc.desc : func test
766 */
767 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0210, TestSize.Level1)
768 {
769 auto demuxerSample = make_unique<InnerDemuxerSample>();
770 demuxerSample->readPos = 4;
771 demuxerSample->indexVid = 0;
772 demuxerSample->indexAud = 4;
773 std::vector<std::vector<int32_t>> cacheCheckSteps = {
774 {0, 0, 0},
775 {1, 630, 630},
776 {2, 630, 630},
777 {3, 630, 630},
778 {4, 630, 315},
779 {5, 630, 630},
780 {6, 630, 630},
781 {7, 630, 630},
782 {8, 630, 630},
783 {9, 630, 630},
784 };
785 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
786 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
787 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
788 }
789
790 /**
791 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0220
792 * @tc.name : mp4(1video+9audio), Read the video track in the middle stage
793 * @tc.desc : func test
794 */
795 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0220, TestSize.Level1)
796 {
797 auto demuxerSample = make_unique<InnerDemuxerSample>();
798 demuxerSample->readPos = 300;
799 demuxerSample->indexVid = 0;
800 demuxerSample->indexAud = 4;
801 std::vector<std::vector<int32_t>> cacheCheckSteps = {
802 {0, 0, 0},
803 {1, 78437, 78437},
804 {2, 78437, 78437},
805 {3, 78437, 78437},
806 {4, 78437, 78122},
807 {5, 78437, 78437},
808 {6, 78437, 78437},
809 {7, 78437, 78437},
810 {8, 78437, 78437},
811 {9, 78437, 78437},
812 };
813 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
814 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
815 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
816 }
817
818 /**
819 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0230
820 * @tc.name : mp4(1video+9audio), Read the video track at the final stage
821 * @tc.desc : func test
822 */
823 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0230, TestSize.Level1)
824 {
825 auto demuxerSample = make_unique<InnerDemuxerSample>();
826 demuxerSample->readPos = 600;
827 demuxerSample->indexVid = 0;
828 demuxerSample->indexAud = 4;
829 std::vector<std::vector<int32_t>> cacheCheckSteps = {
830 {0, 0, 0},
831 {1, 161568, 161568},
832 {2, 161568, 161568},
833 {3, 161568, 161568},
834 {4, 161568, 161253},
835 {5, 161568, 161568},
836 {6, 161568, 161568},
837 {7, 161568, 161568},
838 {8, 161568, 161568},
839 {9, 161568, 161568},
840 };
841 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
842 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
843 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
844 }
845
846 /**
847 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0240
848 * @tc.name : mp4(1video+9audio), Read the audio track at the beginning stage
849 * @tc.desc : func test
850 */
851 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0240, TestSize.Level1)
852 {
853 auto demuxerSample = make_unique<InnerDemuxerSample>();
854 demuxerSample->readPos = 2;
855 demuxerSample->indexVid = 0;
856 demuxerSample->indexAud = 4;
857 std::vector<std::vector<int32_t>> cacheCheckSteps = {
858 {0, 120297, 4877},
859 {1, 630, 630},
860 {2, 630, 630},
861 {3, 630, 630},
862 {4, 0, 0},
863 {5, 315, 315},
864 {6, 315, 315},
865 {7, 315, 315},
866 {8, 315, 315},
867 {9, 315, 315},
868 };
869 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
870 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
871 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
872 }
873
874 /**
875 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0250
876 * @tc.name : mp4(1video+9audio), Read the audio track in the middle stage
877 * @tc.desc : func test
878 */
879 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0250, TestSize.Level1)
880 {
881 auto demuxerSample = make_unique<InnerDemuxerSample>();
882 demuxerSample->readPos = 200;
883 demuxerSample->indexVid = 0;
884 demuxerSample->indexAud = 4;
885 std::vector<std::vector<int32_t>> cacheCheckSteps = {
886 {0, 1756633, 1641213},
887 {1, 72844, 72844},
888 {2, 72844, 72844},
889 {3, 72844, 72844},
890 {4, 0, 0},
891 {5, 72283, 72283},
892 {6, 72283, 72283},
893 {7, 72283, 72283},
894 {8, 72283, 72283},
895 {9, 72283, 72283},
896 };
897 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
898 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
899 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
900 }
901
902 /**
903 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0260
904 * @tc.name : mp4(1video+9audio), Read the audio track at the final stage
905 * @tc.desc : func test
906 */
907 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0260, TestSize.Level1)
908 {
909 auto demuxerSample = make_unique<InnerDemuxerSample>();
910 demuxerSample->readPos = 433;
911 demuxerSample->indexVid = 0;
912 demuxerSample->indexAud = 4;
913 std::vector<std::vector<int32_t>> cacheCheckSteps = {
914 {0, 5024021, 4908601},
915 {1, 162955, 162955},
916 {2, 162955, 162955},
917 {3, 162955, 162955},
918 {4, 0, 0},
919 {5, 162497, 162497},
920 {6, 162497, 162497},
921 {7, 162497, 162497},
922 {8, 162497, 162497},
923 {9, 162497, 162497},
924 };
925 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
926 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
927 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
928 }
929
930 /**
931 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0270
932 * @tc.name : mp4(1video+9audio), unselect track8(audio8),Read the audio4 track at the beginning stage
933 * @tc.desc : func test
934 */
935 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0270, TestSize.Level1)
936 {
937 auto demuxerSample = make_unique<InnerDemuxerSample>();
938 demuxerSample->readPos = 2;
939 demuxerSample->indexVid = 0;
940 demuxerSample->indexAud = 4;
941 demuxerSample->unSelectTrack = 8;
942 std::vector<std::vector<int32_t>> cacheCheckSteps = {
943 {0, 120297, 4877},
944 {1, 630, 630},
945 {2, 630, 630},
946 {3, 630, 630},
947 {4, 0, 0},
948 {5, 315, 315},
949 {6, 315, 315},
950 {7, 315, 315},
951 {9, 315, 315},
952 };
953 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
954 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
955 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
956 }
957
958 /**
959 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0280
960 * @tc.name : mp4(1video+9audio), unselect track8(audio8),Read the audio4 track at the middle stage
961 * @tc.desc : func test
962 */
963 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0280, TestSize.Level1)
964 {
965 auto demuxerSample = make_unique<InnerDemuxerSample>();
966 demuxerSample->readPos = 200;
967 demuxerSample->indexVid = 0;
968 demuxerSample->indexAud = 4;
969 demuxerSample->unSelectTrack = 8;
970 std::vector<std::vector<int32_t>> cacheCheckSteps = {
971 {0, 1756633, 1641213},
972 {1, 72844, 72844},
973 {2, 72844, 72844},
974 {3, 72844, 72844},
975 {4, 0, 0},
976 {5, 72283, 72283},
977 {6, 72283, 72283},
978 {7, 72283, 72283},
979 {9, 72283, 72283},
980 };
981 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
982 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
983 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
984 }
985
986 /**
987 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0290
988 * @tc.name : mp4(1video+9audio), unselect track8(audio8),Read the audio4 track at the final stage
989 * @tc.desc : func test
990 */
991 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0290, TestSize.Level1)
992 {
993 auto demuxerSample = make_unique<InnerDemuxerSample>();
994 demuxerSample->readPos = 433;
995 demuxerSample->indexVid = 0;
996 demuxerSample->indexAud = 4;
997 demuxerSample->unSelectTrack = 8;
998 std::vector<std::vector<int32_t>> cacheCheckSteps = {
999 {0, 5024021, 4908601},
1000 {1, 162955, 162955},
1001 {2, 162955, 162955},
1002 {3, 162955, 162955},
1003 {4, 0, 0},
1004 {5, 162497, 162497},
1005 {6, 162497, 162497},
1006 {7, 162497, 162497},
1007 {9, 162497, 162497},
1008 };
1009 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/video_9audio.mp4", true), AVCS_ERR_OK);
1010 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1011 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1012 }
1013
1014 /**
1015 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0300
1016 * @tc.name : mkv(1video+1audio), Read the video track in the middle stage
1017 * @tc.desc : func test
1018 */
1019 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0300, TestSize.Level1)
1020 {
1021 auto demuxerSample = make_unique<InnerDemuxerSample>();
1022 demuxerSample->readPos = 2;
1023 demuxerSample->indexVid = 0;
1024 demuxerSample->indexAud = 1;
1025 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1026 {0, 0, 0},
1027 {1, 3, 0},
1028 };
1029 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/opus_h264.mkv", true), AVCS_ERR_OK);
1030 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1031 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1032 }
1033
1034 /**
1035 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0310
1036 * @tc.name : mkv(1video+1audio), Read the video track in the middle stage
1037 * @tc.desc : func test
1038 */
1039 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0310, TestSize.Level1)
1040 {
1041 auto demuxerSample = make_unique<InnerDemuxerSample>();
1042 demuxerSample->readPos = 180;
1043 demuxerSample->indexVid = 0;
1044 demuxerSample->indexAud = 1;
1045 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1046 {0, 0, 0},
1047 {1, 54019, 54016},
1048 };
1049 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/opus_h264.mkv", true), AVCS_ERR_OK);
1050 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1051 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1052 }
1053
1054 /**
1055 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0320
1056 * @tc.name : mkv(1video+1audio), Read the video track at the final stage
1057 * @tc.desc : func test
1058 */
1059 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0320, TestSize.Level1)
1060 {
1061 auto demuxerSample = make_unique<InnerDemuxerSample>();
1062 demuxerSample->readPos = 372;
1063 demuxerSample->indexVid = 0;
1064 demuxerSample->indexAud = 1;
1065 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1066 {0, 0, 0},
1067 {1, 116656, 116653},
1068 };
1069 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/opus_h264.mkv", true), AVCS_ERR_OK);
1070 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1071 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1072 }
1073
1074 /**
1075 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0330
1076 * @tc.name : mkv(1video+1audio),Read the audio track at the beginning stage
1077 * @tc.desc : func test
1078 */
1079 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0330, TestSize.Level3)
1080 {
1081 auto demuxerSample = make_unique<InnerDemuxerSample>();
1082 demuxerSample->readPos = 2;
1083 demuxerSample->indexVid = 0;
1084 demuxerSample->indexAud = 1;
1085 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1086 {0, 69641, 19550},
1087 {1, 0, 0},
1088 };
1089 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/opus_h264.mkv", true), AVCS_ERR_OK);
1090 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1091 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1092 }
1093 /**
1094 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0340
1095 * @tc.name : mkv(1video+1audio),Read the audio track at the middle stage
1096 * @tc.desc : func test
1097 */
1098 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0340, TestSize.Level3)
1099 {
1100 auto demuxerSample = make_unique<InnerDemuxerSample>();
1101 demuxerSample->readPos = 300;
1102 demuxerSample->indexVid = 0;
1103 demuxerSample->indexAud = 1;
1104 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1105 {0, 3227617, 3177526},
1106 {1, 0, 0},
1107 };
1108 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/opus_h264.mkv", true), AVCS_ERR_OK);
1109 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1110 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1111 }
1112 /**
1113 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0350
1114 * @tc.name : mkv(1video+1audio),Read the audio track at the final stage
1115 * @tc.desc : func test
1116 */
1117 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0350, TestSize.Level3)
1118 {
1119 auto demuxerSample = make_unique<InnerDemuxerSample>();
1120 demuxerSample->readPos = 610;
1121 demuxerSample->indexVid = 0;
1122 demuxerSample->indexAud = 1;
1123 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1124 {0, 6585274, 6535183},
1125 {1, 0, 0},
1126 };
1127 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/opus_h264.mkv", true), AVCS_ERR_OK);
1128 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1129 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1130 }
1131 /**
1132 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0360
1133 * @tc.name : ts(1video+1audio),Read the video track at the beginning stage
1134 * @tc.desc : func test
1135 */
1136 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0360, TestSize.Level3)
1137 {
1138 auto demuxerSample = make_unique<InnerDemuxerSample>();
1139 demuxerSample->readPos = 10;
1140 demuxerSample->indexVid = 0;
1141 demuxerSample->indexAud = 1;
1142 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1143 {0, 0, 0},
1144 {1, 2742, 2712},
1145 };
1146 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/aac_mpeg4.ts", true), AVCS_ERR_OK);
1147 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1148 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1149 }
1150 /**
1151 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0370
1152 * @tc.name : ts(1video+1audio),Read the video track at the middle stage
1153 * @tc.desc : func test
1154 */
1155 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0370, TestSize.Level3)
1156 {
1157 auto demuxerSample = make_unique<InnerDemuxerSample>();
1158 demuxerSample->readPos = 180;
1159 demuxerSample->indexVid = 0;
1160 demuxerSample->indexAud = 1;
1161 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1162 {0, 0, 0},
1163 {1, 78573, 78543},
1164 };
1165 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/aac_mpeg4.ts", true), AVCS_ERR_OK);
1166 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1167 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1168 }
1169 /**
1170 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0380
1171 * @tc.name : ts(1video+1audio),Read the video track at the final stage
1172 * @tc.desc : func test
1173 */
1174 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0380, TestSize.Level3)
1175 {
1176 auto demuxerSample = make_unique<InnerDemuxerSample>();
1177 demuxerSample->readPos = 372;
1178 demuxerSample->indexVid = 0;
1179 demuxerSample->indexAud = 1;
1180 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1181 {0, 0, 0},
1182 {1, 163470, 163440},
1183 };
1184 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/aac_mpeg4.ts", true), AVCS_ERR_OK);
1185 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1186 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1187 }
1188 /**
1189 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0390
1190 * @tc.name : ts(1video+1audio),Read the audio track at the beginning stage
1191 * @tc.desc : func test
1192 */
1193 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0390, TestSize.Level3)
1194 {
1195 auto demuxerSample = make_unique<InnerDemuxerSample>();
1196 demuxerSample->readPos = 10;
1197 demuxerSample->indexVid = 0;
1198 demuxerSample->indexAud = 1;
1199 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1200 {0, 534706, 453412},
1201 {1, 0, 0},
1202 };
1203 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/aac_mpeg4.ts", true), AVCS_ERR_OK);
1204 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1205 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1206 }
1207 /**
1208 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0400
1209 * @tc.name : ts(1video+1audio),Read the audio track at the middle stage
1210 * @tc.desc : func test
1211 */
1212 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0400, TestSize.Level3)
1213 {
1214 auto demuxerSample = make_unique<InnerDemuxerSample>();
1215 demuxerSample->readPos = 300;
1216 demuxerSample->indexVid = 0;
1217 demuxerSample->indexAud = 1;
1218 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1219 {0, 4933778, 4852484},
1220 {1, 0, 0},
1221 };
1222 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/aac_mpeg4.ts", true), AVCS_ERR_OK);
1223 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1224 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1225 }
1226 /**
1227 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0410
1228 * @tc.name : ts(1video+1audio),Read the audio track at the final stage
1229 * @tc.desc : func test
1230 */
1231 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0410, TestSize.Level3)
1232 {
1233 auto demuxerSample = make_unique<InnerDemuxerSample>();
1234 demuxerSample->readPos = 528;
1235 demuxerSample->indexVid = 0;
1236 demuxerSample->indexAud = 1;
1237 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1238 {0, 8598818, 8517524},
1239 {1, 0, 0},
1240 };
1241 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/aac_mpeg4.ts", true), AVCS_ERR_OK);
1242 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1243 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1244 }
1245 /**
1246 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0420
1247 * @tc.name : fmp4(1video+1audio),Read the video track at the beginning stage
1248 * @tc.desc : func test
1249 */
1250 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0420, TestSize.Level3)
1251 {
1252 auto demuxerSample = make_unique<InnerDemuxerSample>();
1253 demuxerSample->readPos = 4;
1254 demuxerSample->indexVid = 0;
1255 demuxerSample->indexAud = 1;
1256 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1257 {0, 0, 0},
1258 {1, 1671, 1254},
1259 };
1260 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/mp3_h265_fmp4.mp4", true), AVCS_ERR_OK);
1261 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1262 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1263 }
1264 /**
1265 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0430
1266 * @tc.name : fmp4(1video+1audio),Read the video track at the middle stage
1267 * @tc.desc : func test
1268 */
1269 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0430, TestSize.Level3)
1270 {
1271 auto demuxerSample = make_unique<InnerDemuxerSample>();
1272 demuxerSample->readPos = 180;
1273 demuxerSample->indexVid = 0;
1274 demuxerSample->indexAud = 1;
1275 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1276 {0, 0, 0},
1277 {1, 93622, 93205},
1278 };
1279 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/mp3_h265_fmp4.mp4", true), AVCS_ERR_OK);
1280 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1281 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1282 }
1283 /**
1284 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0440
1285 * @tc.name : fmp4(1video+1audio),Read the video track at the final stage
1286 * @tc.desc : func test
1287 */
1288 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0440, TestSize.Level3)
1289 {
1290 auto demuxerSample = make_unique<InnerDemuxerSample>();
1291 demuxerSample->readPos = 372;
1292 demuxerSample->indexVid = 0;
1293 demuxerSample->indexAud = 1;
1294 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1295 {0, 0, 0},
1296 {1, 194769, 194352},
1297 };
1298 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/mp3_h265_fmp4.mp4", true), AVCS_ERR_OK);
1299 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1300 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1301 }
1302 /**
1303 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0450
1304 * @tc.name : fmp4(1video+1audio),Read the audio track at the beginning stage
1305 * @tc.desc : func test
1306 */
1307 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0450, TestSize.Level3)
1308 {
1309 auto demuxerSample = make_unique<InnerDemuxerSample>();
1310 demuxerSample->readPos = 4;
1311 demuxerSample->indexVid = 0;
1312 demuxerSample->indexAud = 1;
1313 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1314 {0, 33263, 248},
1315 {1, 0, 0},
1316 };
1317 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/mp3_h265_fmp4.mp4", true), AVCS_ERR_OK);
1318 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1319 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1320 }
1321 /**
1322 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0460
1323 * @tc.name : fmp4(1video+1audio),Read the audio track at the middle stage
1324 * @tc.desc : func test
1325 */
1326 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0460, TestSize.Level3)
1327 {
1328 auto demuxerSample = make_unique<InnerDemuxerSample>();
1329 demuxerSample->readPos = 300;
1330 demuxerSample->indexVid = 0;
1331 demuxerSample->indexAud = 1;
1332 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1333 {0, 1553199, 1520184},
1334 {1, 0, 0},
1335 };
1336 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/mp3_h265_fmp4.mp4", true), AVCS_ERR_OK);
1337 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1338 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1339 }
1340 /**
1341 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0470
1342 * @tc.name : fmp4(1video+1audio),Read the audio track at the final stage
1343 * @tc.desc : func test
1344 */
1345 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0470, TestSize.Level3)
1346 {
1347 auto demuxerSample = make_unique<InnerDemuxerSample>();
1348 demuxerSample->readPos = 468;
1349 demuxerSample->indexVid = 0;
1350 demuxerSample->indexAud = 1;
1351 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1352 {0, 2419189, 2386174},
1353 {1, 0, 0},
1354 };
1355 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/mp3_h265_fmp4.mp4", true), AVCS_ERR_OK);
1356 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1357 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1358 }
1359 /**
1360 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0480
1361 * @tc.name : flv(1video+1audio),Read the video track at the beginning stage
1362 * @tc.desc : func test
1363 */
1364 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0480, TestSize.Level3)
1365 {
1366 auto demuxerSample = make_unique<InnerDemuxerSample>();
1367 demuxerSample->readPos = 4;
1368 demuxerSample->indexVid = 0;
1369 demuxerSample->indexAud = 1;
1370 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1371 {0, 0, 0},
1372 {1, 1260, 478},
1373 };
1374 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/hevc_aac_first.flv", true), AVCS_ERR_OK);
1375 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1376 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1377 }
1378 /**
1379 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0490
1380 * @tc.name : flv(1video+1audio),Read the video track at the middle stage
1381 * @tc.desc : func test
1382 */
1383 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0490, TestSize.Level3)
1384 {
1385 auto demuxerSample = make_unique<InnerDemuxerSample>();
1386 demuxerSample->readPos = 300;
1387 demuxerSample->indexVid = 0;
1388 demuxerSample->indexAud = 1;
1389 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1390 {0, 0, 0},
1391 {1, 78538, 77756},
1392 };
1393 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/hevc_aac_first.flv", true), AVCS_ERR_OK);
1394 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1395 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1396 }
1397 /**
1398 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0500
1399 * @tc.name : flv(1video+1audio),Read the video track at the final stage
1400 * @tc.desc : func test
1401 */
1402 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0500, TestSize.Level3)
1403 {
1404 auto demuxerSample = make_unique<InnerDemuxerSample>();
1405 demuxerSample->readPos = 602;
1406 demuxerSample->indexVid = 0;
1407 demuxerSample->indexAud = 1;
1408 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1409 {0, 0, 0},
1410 {1, 165632, 164850},
1411 };
1412 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/hevc_aac_first.flv", true), AVCS_ERR_OK);
1413 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1414 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1415 }
1416 /**
1417 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0510
1418 * @tc.name : flv(1video+1audio),Read the audio track at the beginning stage
1419 * @tc.desc : func test
1420 */
1421 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0510, TestSize.Level3)
1422 {
1423 auto demuxerSample = make_unique<InnerDemuxerSample>();
1424 demuxerSample->readPos = 4;
1425 demuxerSample->indexVid = 0;
1426 demuxerSample->indexAud = 1;
1427 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1428 {0, 110977, 17555},
1429 {1, 0, 0},
1430 };
1431 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/hevc_aac_first.flv", true), AVCS_ERR_OK);
1432 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1433 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1434 }
1435 /**
1436 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0520
1437 * @tc.name : flv(1video+1audio),Read the audio track at the middle stage
1438 * @tc.desc : func test
1439 */
1440 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0520, TestSize.Level3)
1441 {
1442 auto demuxerSample = make_unique<InnerDemuxerSample>();
1443 demuxerSample->readPos = 100;
1444 demuxerSample->indexVid = 0;
1445 demuxerSample->indexAud = 1;
1446 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1447 {0, 2157637, 2064215},
1448 {1, 0, 0},
1449 };
1450 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/hevc_aac_first.flv", true), AVCS_ERR_OK);
1451 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1452 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1453 }
1454 /**
1455 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0530
1456 * @tc.name : flv(1video+1audio),Read the audio track at the final stage
1457 * @tc.desc : func test
1458 */
1459 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0530, TestSize.Level3)
1460 {
1461 auto demuxerSample = make_unique<InnerDemuxerSample>();
1462 demuxerSample->readPos = 210;
1463 demuxerSample->indexVid = 0;
1464 demuxerSample->indexAud = 1;
1465 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1466 {0, 5435273, 5341851},
1467 {1, 0, 0},
1468 };
1469 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/hevc_aac_first.flv", true), AVCS_ERR_OK);
1470 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1471 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1472 }
1473 /**
1474 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0540
1475 * @tc.name : mov(1video+1audio),Read the video track at the beginning stage
1476 * @tc.desc : func test
1477 */
1478 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0540, TestSize.Level3)
1479 {
1480 auto demuxerSample = make_unique<InnerDemuxerSample>();
1481 demuxerSample->readPos = 4;
1482 demuxerSample->indexVid = 0;
1483 demuxerSample->indexAud = 1;
1484 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1485 {0, 0, 0},
1486 {1, 6912, 5184},
1487 };
1488 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG4_SP@6_1280_720_30_MP2_32K_2.mov", true), AVCS_ERR_OK);
1489 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1490 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1491 }
1492 /**
1493 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0550
1494 * @tc.name : mov(1video+1audio),Read the video track at the middle stage
1495 * @tc.desc : func test
1496 */
1497 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0550, TestSize.Level3)
1498 {
1499 auto demuxerSample = make_unique<InnerDemuxerSample>();
1500 demuxerSample->readPos = 30;
1501 demuxerSample->indexVid = 0;
1502 demuxerSample->indexAud = 1;
1503 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1504 {0, 0, 0},
1505 {1, 48384, 46656},
1506 };
1507 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG4_SP@6_1280_720_30_MP2_32K_2.mov", true), AVCS_ERR_OK);
1508 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1509 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1510 }
1511 /**
1512 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0560
1513 * @tc.name : mov(1video+1audio),Read the video track at the final stage
1514 * @tc.desc : func test
1515 */
1516 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0560, TestSize.Level3)
1517 {
1518 auto demuxerSample = make_unique<InnerDemuxerSample>();
1519 demuxerSample->readPos = 60;
1520 demuxerSample->indexVid = 0;
1521 demuxerSample->indexAud = 1;
1522 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1523 {0, 0, 0},
1524 {1, 96768, 95040},
1525 };
1526 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG4_SP@6_1280_720_30_MP2_32K_2.mov", true), AVCS_ERR_OK);
1527 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1528 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1529 }
1530 /**
1531 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0570
1532 * @tc.name : mov(1video+1audio),Read the audio track at the beginning stage
1533 * @tc.desc : func test
1534 */
1535 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0570, TestSize.Level3)
1536 {
1537 auto demuxerSample = make_unique<InnerDemuxerSample>();
1538 demuxerSample->readPos = 4;
1539 demuxerSample->indexVid = 0;
1540 demuxerSample->indexAud = 1;
1541 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1542 {0, 68577, 5564},
1543 {1, 0, 0},
1544 };
1545 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG4_SP@6_1280_720_30_MP2_32K_2.mov", true), AVCS_ERR_OK);
1546 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1547 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1548 }
1549 /**
1550 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0580
1551 * @tc.name : mov(1video+1audio),Read the audio track at the middle stage
1552 * @tc.desc : func test
1553 */
1554 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0580, TestSize.Level3)
1555 {
1556 auto demuxerSample = make_unique<InnerDemuxerSample>();
1557 demuxerSample->readPos = 30;
1558 demuxerSample->indexVid = 0;
1559 demuxerSample->indexAud = 1;
1560 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1561 {0, 206841, 143828},
1562 {1, 0, 0},
1563 };
1564 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG4_SP@6_1280_720_30_MP2_32K_2.mov", true), AVCS_ERR_OK);
1565 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1566 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1567 }
1568 /**
1569 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0590
1570 * @tc.name : mov(1video+1audio),Read the audio track at the final stage
1571 * @tc.desc : func test
1572 */
1573 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0590, TestSize.Level3)
1574 {
1575 auto demuxerSample = make_unique<InnerDemuxerSample>();
1576 demuxerSample->readPos = 56;
1577 demuxerSample->indexVid = 0;
1578 demuxerSample->indexAud = 1;
1579 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1580 {0, 354199, 291186},
1581 {1, 0, 0},
1582 };
1583 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG4_SP@6_1280_720_30_MP2_32K_2.mov", true), AVCS_ERR_OK);
1584 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1585 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1586 }
1587 /**
1588 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0600
1589 * @tc.name : avi(1video+1audio),Read the video track at the beginning stage
1590 * @tc.desc : func test
1591 */
1592 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0600, TestSize.Level3)
1593 {
1594 auto demuxerSample = make_unique<InnerDemuxerSample>();
1595 demuxerSample->readPos = 4;
1596 demuxerSample->indexVid = 0;
1597 demuxerSample->indexAud = 1;
1598 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1599 {0, 0, 0},
1600 {1, 24576, 20480},
1601 };
1602 ASSERT_EQ(demuxerSample->InitWithFile(
1603 "/data/test/media/AVI_MPEG4_main@level5_720_576_PCM_s32_1.avi", true), AVCS_ERR_OK);
1604 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1605 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1606 }
1607 /**
1608 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0610
1609 * @tc.name : avi(1video+1audio),Read the video track at the middle stage
1610 * @tc.desc : func test
1611 */
1612 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0610, TestSize.Level3)
1613 {
1614 auto demuxerSample = make_unique<InnerDemuxerSample>();
1615 demuxerSample->readPos = 15;
1616 demuxerSample->indexVid = 0;
1617 demuxerSample->indexAud = 1;
1618 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1619 {0, 0, 0},
1620 {1, 86016, 81920},
1621 };
1622 ASSERT_EQ(demuxerSample->InitWithFile(
1623 "/data/test/media/AVI_MPEG4_main@level5_720_576_PCM_s32_1.avi", true), AVCS_ERR_OK);
1624 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1625 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1626 }
1627 /**
1628 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0620
1629 * @tc.name : avi(1video+1audio),Read the video track at the final stage
1630 * @tc.desc : func test
1631 */
1632 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0620, TestSize.Level3)
1633 {
1634 auto demuxerSample = make_unique<InnerDemuxerSample>();
1635 demuxerSample->readPos = 30;
1636 demuxerSample->indexVid = 0;
1637 demuxerSample->indexAud = 1;
1638 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1639 {0, 0, 0},
1640 {1, 176128, 172032},
1641 };
1642 ASSERT_EQ(demuxerSample->InitWithFile(
1643 "/data/test/media/AVI_MPEG4_main@level5_720_576_PCM_s32_1.avi", true), AVCS_ERR_OK);
1644 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1645 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1646 }
1647 /**
1648 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0630
1649 * @tc.name : avi(1video+1audio),Read the audio track at the beginning stage
1650 * @tc.desc : func test
1651 */
1652 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0630, TestSize.Level3)
1653 {
1654 auto demuxerSample = make_unique<InnerDemuxerSample>();
1655 demuxerSample->readPos = 4;
1656 demuxerSample->indexVid = 0;
1657 demuxerSample->indexAud = 1;
1658 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1659 {0, 70742, 30302},
1660 {1, 0, 0},
1661 };
1662 ASSERT_EQ(demuxerSample->InitWithFile(
1663 "/data/test/media/AVI_MPEG4_main@level5_720_576_PCM_s32_1.avi", true), AVCS_ERR_OK);
1664 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1665 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1666 }
1667 /**
1668 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0640
1669 * @tc.name : avi(1video+1audio),Read the audio track at the middle stage
1670 * @tc.desc : func test
1671 */
1672 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0640, TestSize.Level3)
1673 {
1674 auto demuxerSample = make_unique<InnerDemuxerSample>();
1675 demuxerSample->readPos = 20;
1676 demuxerSample->indexVid = 0;
1677 demuxerSample->indexAud = 1;
1678 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1679 {0, 207760, 167320},
1680 {1, 0, 0},
1681 };
1682 ASSERT_EQ(demuxerSample->InitWithFile(
1683 "/data/test/media/AVI_MPEG4_main@level5_720_576_PCM_s32_1.avi", true), AVCS_ERR_OK);
1684 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1685 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1686 }
1687 /**
1688 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0650
1689 * @tc.name : avi(1video+1audio),Read the audio track at the final stage
1690 * @tc.desc : func test
1691 */
1692 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0650, TestSize.Level3)
1693 {
1694 auto demuxerSample = make_unique<InnerDemuxerSample>();
1695 demuxerSample->readPos = 44;
1696 demuxerSample->indexVid = 0;
1697 demuxerSample->indexAud = 1;
1698 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1699 {0, 305390, 264950},
1700 {1, 0, 0},
1701 };
1702 ASSERT_EQ(demuxerSample->InitWithFile(
1703 "/data/test/media/AVI_MPEG4_main@level5_720_576_PCM_s32_1.avi", true), AVCS_ERR_OK);
1704 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1705 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1706 }
1707 /**
1708 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0660
1709 * @tc.name : mpg(1video+1audio),Read the video track at the beginning stage
1710 * @tc.desc : func test
1711 */
1712 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0660, TestSize.Level3)
1713 {
1714 auto demuxerSample = make_unique<InnerDemuxerSample>();
1715 demuxerSample->readPos = 4;
1716 demuxerSample->indexVid = 0;
1717 demuxerSample->indexAud = 1;
1718 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1719 {0, 0, 0},
1720 {1, 1944, 1728},
1721 };
1722 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG2_422p_1280_720_60_MP3_32K_1.mpg", true), AVCS_ERR_OK);
1723 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1724 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1725 }
1726 /**
1727 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0670
1728 * @tc.name : mpg(1video+1audio),Read the video track at the middle stage
1729 * @tc.desc : func test
1730 */
1731 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0670, TestSize.Level3)
1732 {
1733 auto demuxerSample = make_unique<InnerDemuxerSample>();
1734 demuxerSample->readPos = 60;
1735 demuxerSample->indexVid = 0;
1736 demuxerSample->indexAud = 1;
1737 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1738 {0, 0, 0},
1739 {1, 3888, 3672},
1740 };
1741 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG2_422p_1280_720_60_MP3_32K_1.mpg", true), AVCS_ERR_OK);
1742 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1743 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1744 }
1745 /**
1746 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0680
1747 * @tc.name : mpg(1video+1audio),Read the video track at the final stage
1748 * @tc.desc : func test
1749 */
1750 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0680, TestSize.Level3)
1751 {
1752 auto demuxerSample = make_unique<InnerDemuxerSample>();
1753 demuxerSample->readPos = 119;
1754 demuxerSample->indexVid = 0;
1755 demuxerSample->indexAud = 1;
1756 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1757 {0, 0, 0},
1758 {1, 12312, 12096},
1759 };
1760 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG2_422p_1280_720_60_MP3_32K_1.mpg", true), AVCS_ERR_OK);
1761 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1762 ASSERT_EQ(demuxerSample->ReadVideo(cacheCheckSteps), true);
1763 }
1764 /**
1765 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0690
1766 * @tc.name : mpg(1video+1audio),Read the audio track at the beginning stage
1767 * @tc.desc : func test
1768 */
1769 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0690, TestSize.Level3)
1770 {
1771 auto demuxerSample = make_unique<InnerDemuxerSample>();
1772 demuxerSample->readPos = 10;
1773 demuxerSample->indexVid = 0;
1774 demuxerSample->indexAud = 1;
1775 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1776 {0, 94517, 63753},
1777 {1, 0, 0},
1778 };
1779 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG2_422p_1280_720_60_MP3_32K_1.mpg", true), AVCS_ERR_OK);
1780 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1781 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1782 }
1783 /**
1784 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0700
1785 * @tc.name : mpg(1video+1audio),Read the audio track at the middle stage
1786 * @tc.desc : func test
1787 */
1788 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0700, TestSize.Level3)
1789 {
1790 auto demuxerSample = make_unique<InnerDemuxerSample>();
1791 demuxerSample->readPos = 30;
1792 demuxerSample->indexVid = 0;
1793 demuxerSample->indexAud = 1;
1794 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1795 {0, 421101, 390337},
1796 {1, 0, 0},
1797 };
1798 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG2_422p_1280_720_60_MP3_32K_1.mpg", true), AVCS_ERR_OK);
1799 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1800 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1801 }
1802 /**
1803 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0710
1804 * @tc.name : mpg(1video+1audio),Read the audio track at the final stage
1805 * @tc.desc : func test
1806 */
1807 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0710, TestSize.Level3)
1808 {
1809 auto demuxerSample = make_unique<InnerDemuxerSample>();
1810 demuxerSample->readPos = 57;
1811 demuxerSample->indexVid = 0;
1812 demuxerSample->indexAud = 1;
1813 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1814 {0, 652380, 621616},
1815 {1, 0, 0},
1816 };
1817 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/MPEG2_422p_1280_720_60_MP3_32K_1.mpg", true), AVCS_ERR_OK);
1818 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1819 ASSERT_EQ(demuxerSample->ReadAudio(cacheCheckSteps), true);
1820 }
1821 /**
1822 * @tc.number : DEMUXER_CACHESIZE_INNER_FUNC_0720
1823 * @tc.name : mp3(1audio),Read the audio,get audio ,size = 0
1824 * @tc.desc : func test
1825 */
1826 HWTEST_F(DemuxerCacheFuncNdkTest, DEMUXER_CACHESIZE_INNER_FUNC_0720, TestSize.Level3)
1827 {
1828 auto demuxerSample = make_unique<InnerDemuxerSample>();
1829 demuxerSample->readPos = 10;
1830 demuxerSample->indexAud = 0;
1831 std::vector<std::vector<int32_t>> cacheCheckSteps = {
1832 {0, 0},
1833 };
1834 int32_t readCount = 0;
1835 ASSERT_EQ(demuxerSample->InitWithFile("/data/test/media/audio/gb2312.mp3", true), AVCS_ERR_OK);
1836 ASSERT_EQ(demuxerSample->CreateBuffer(), true);
1837 while (true)
1838 {
1839 if (readCount >= demuxerSample->readPos)
1840 {
1841 ASSERT_EQ(true, demuxerSample->CheckCache(cacheCheckSteps, 1));
1842 break;
1843 } else {
1844 readCount++;
1845 demuxerSample->demuxer_->ReadSampleBuffer(demuxerSample->indexAud, demuxerSample->avBuffer);
1846 }
1847 }
1848 }
1849 }
1850