Lines Matching refs:pos
27 long long mkvparser::ReadUInt(IMkvReader* pReader, long long pos, long& len)
30 assert(pos >= 0);
39 // assert(pos < available);
40 // assert((available - pos) >= 1); //assume here max u-int len is 8
47 status = pReader->Read(pos, 1, &b);
67 // assert((available - pos) >= len);
71 ++pos;
75 status = pReader->Read(pos, 1, &b);
92 ++pos;
100 long long pos,
104 assert(pos >= 0);
114 if (pos >= available)
115 return pos; //too few bytes available
119 status = pReader->Read(pos, 1, &b);
142 long long pos,
148 if (pos >= stop)
153 long hr = pReader->Read(pos, 1, &b);
173 if ((pos + len) > stop)
177 ++pos;
181 hr = pReader->Read(pos, 1, &b);
192 ++pos;
201 long long pos,
205 assert(pos >= 0);
215 const long status = pReader->Read(pos, 1, &b);
223 ++pos;
232 long long pos)
235 assert(pos >= 0);
244 assert((pos + 4) <= available);
256 hr = pReader->Read(pos, 1, --q);
262 ++pos;
277 const int status = pReader->Read(pos++, 1, &b);
297 long long pos)
300 assert(pos >= 0);
310 const long hr = pReader->Read(pos, 1, --q);
316 ++pos;
331 const int status = pReader->Read(pos++, 1, &b);
350 long long pos)
353 assert(pos >= 0);
362 assert(pos < available);
369 const int status = pReader->Read(pos, 1, &b);
377 long long pos)
380 assert(pos >= 0);
389 assert((pos + 2) <= available);
401 hr = pReader->Read(pos, 1, --q);
407 ++pos;
416 const int status = pReader->Read(pos++, 1, &b);
434 long long& pos,
439 assert(pos >= 0);
449 const long long id = ReadUInt(pReader, pos, len);
453 assert((pos + len) <= available);
458 pos += len; //consume id
460 const long long size = ReadUInt(pReader, pos, len);
465 assert((pos + len) <= available);
467 pos += len; //consume length of size of payload
469 val = UnserializeUInt(pReader, pos, size);
472 pos += size; //consume size of payload
479 long long& pos,
484 assert(pos >= 0);
494 const long long id = ReadUInt(pReader, pos, len);
498 assert((pos + len) <= available);
503 pos += len; //consume id
505 const long long size_ = ReadUInt(pReader, pos, len);
509 assert((pos + len) <= available);
511 pos += len; //consume length of size of payload
512 assert((pos + size_) <= available);
521 status = pReader->Read(pos + i, 1, (unsigned char*)&c);
531 pos += size_; //consume size of payload
538 long long& pos,
544 assert(pos >= 0);
553 const long long id = ReadUInt(pReader, pos, len);
557 assert((pos + len) <= available);
562 pos += len; //consume id
564 const long long size_ = ReadUInt(pReader, pos, len);
568 assert((pos + len) <= available);
570 pos += len; //consume length of size of payload
571 assert((pos + size_) <= available);
578 status = pReader->Read(pos, buflen_, buf);
583 pos += size_; //consume size of payload
590 long long& pos,
595 assert(pos >= 0);
605 const long long id = ReadUInt(pReader, pos, idlen);
612 const long long size = ReadUInt(pReader, pos + idlen, sizelen);
623 pos += idlen + sizelen; //consume id and size fields
624 assert((pos + size) <= available);
627 val = Unserialize4Float(pReader, pos);
631 val = Unserialize8Double(pReader, pos);
634 pos += size; //consume size of payload
642 long long& pos,
647 assert(pos >= 0);
656 const long long id = ReadUInt(pReader, pos, len);
658 assert((pos + len) <= available);
663 pos += len; //consume id
665 const long long size = ReadUInt(pReader, pos, len);
667 assert((pos + len) <= available);
669 pos += len; //consume length of size of payload
670 assert((pos + size) <= available);
675 val = Unserialize1SInt(pReader, pos);
677 val = Unserialize2SInt(pReader, pos);
679 pos += size; //consume size of payload
718 long long& pos)
729 pos = 0;
736 while (pos < end)
738 status = pReader->Read(pos, 1, &b);
746 ++pos;
751 if (pos >= 1024)
760 if ((total >= 0) && ((total - pos) < 5))
763 if ((available - pos) < 5)
764 return pos + 5; //try again later
768 const long long result = ReadUInt(pReader, pos, len);
775 pos += len; //consume ID
779 ++pos; //throw away just the 0x1A byte, and try again
782 //pos designates start of size field
787 long long result = GetUIntLength(pReader, pos, len);
798 if ((total >= 0) && ((total - pos) < len))
801 if ((available - pos) < len)
802 return pos + len; //try again later
806 result = ReadUInt(pReader, pos, len);
811 pos += len; //consume size field
813 //pos now designates start of payload
815 pos) < result))
818 if ((available - pos) < result)
819 return pos + result;
821 end = pos + result;
825 while (pos < end)
827 if (Match(pReader, pos, 0x0286, m_version))
829 else if (Match(pReader, pos, 0x02F7, m_readVersion))
831 else if (Match(pReader, pos, 0x02F2, m_maxIdLength))
833 else if (Match(pReader, pos, 0x02F3, m_maxSizeLength))
835 else if (Match(pReader, pos, 0x0282, m_docType))
837 else if (Match(pReader, pos, 0x0287, m_docTypeVersion))
839 else if (Match(pReader, pos, 0x0285, m_docTypeReadVersion))
843 result = ReadUInt(pReader, pos, len);
848 pos += len;
849 assert(pos < end);
851 result = ReadUInt(pReader, pos, len);
856 pos += len + result;
857 assert(pos <= end);
861 assert(pos == end);
913 long long pos,
917 assert(pos >= 0);
954 while (pos < end)
959 long long result = GetUIntLength(pReader, pos, len);
964 if ((pos + len) > end)
967 if ((pos + len) > available)
968 return pos + len;
970 const long long id = ReadUInt(pReader, pos, len);
975 pos += len; //consume ID
979 result = GetUIntLength(pReader, pos, len);
984 if ((pos + len) > end)
987 if ((pos + len) > available)
988 return pos + len;
990 long long size = ReadUInt(pReader, pos, len);
995 pos += len; //consume length of size of element
997 //Pos now points to start of payload
1011 else if ((pos + size) > end)
1014 else if ((pos + size) > total)
1018 pSegment = new (std::nothrow) Segment(pReader, pos, size);
1029 if ((pos + size) > end)
1032 pos += size; //consume payload
1043 //and pos designates start of payload. We need to find the
1063 long long pos = m_pos;
1064 const long long element_start = pos;
1066 if ((pos + 1) > available)
1067 return (pos + 1);
1070 long long result = GetUIntLength(m_pReader, pos, len);
1076 return (pos + 1);
1078 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
1081 if ((pos + len) > available)
1082 return pos + len;
1084 const long long idpos = pos;
1093 pos += len; //consume ID
1095 if ((pos + 1) > available)
1096 return (pos + 1);
1099 result = GetUIntLength(m_pReader, pos, len);
1105 return (pos + 1);
1107 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
1110 if ((pos + len) > available)
1111 return pos + len;
1113 const long long size = ReadUInt(m_pReader, pos, len);
1118 pos += len; //consume length of size of element
1120 const long long element_size = size + pos - element_start;
1122 //Pos now points to start of payload
1124 if ((segment_stop >= 0) && ((pos + size) > segment_stop))
1129 if ((pos + size) > available)
1130 return pos + size;
1137 pos,
1148 pos,
1159 pos,
1170 ParseSeekHead(pos, size);
1175 pos,
1185 m_pos = pos + size; //consume payload
1201 long Segment::FindNextCluster(long long& pos, size& len) const
1204 //and pos designates start of payload. We need to find the
1217 pos = m_pos;
1219 while (pos < stop)
1221 long long result = GetUIntLength(m_pReader, pos, len);
1229 if ((pos + len) > stop)
1232 if ((pos + len) > available)
1235 const long long idpos = pos;
1241 pos += len; //consume ID
1244 result = GetUIntLength(m_pReader, pos, len);
1252 if ((pos + len) > stop)
1255 if ((pos + len) > available)
1258 const long long size = ReadUInt(m_pReader, pos, len);
1263 pos += len; //consume length of size of element
1265 //Pos now points to start of payload
1267 if ((pos + size) > stop)
1270 if ((pos + size) > available)
1279 pos += size; //consume payload
1296 long long pos = m_pos;
1298 while (pos < stop)
1301 const long long idpos = pos;
1303 const long long id = SyncReadUInt(m_pReader, pos, stop, len);
1311 pos += len; //consume id
1312 assert(pos < stop);
1314 const long long size = SyncReadUInt(m_pReader, pos, stop, len);
1319 pos += len; //consume size
1320 assert(pos <= stop);
1325 //pos now points to start of payload
1327 pos += size; //consume payload
1328 assert(pos <= stop);
1342 assert(pos <= stop);
1351 new_pos = stop; //pos >= 0 here means EOF (cluster is NULL)
1358 if (pos >= stop) //we parsed the entire segment
1373 //Read the last byte of the file. (Reading 0 bytes at pos
1381 const int result = m_pReader->Read(pos - 1, 1, &b);
1389 const long long idpos = pos;
1391 const long long id = SyncReadUInt(m_pReader, pos, stop, len);
1399 pos += len; //consume id
1400 assert(pos < stop);
1402 const long long size = SyncReadUInt(m_pReader, pos, stop, len);
1414 bool Segment::AddCluster(long long off, long long pos)
1416 assert(pos >= m_start);
1419 assert(pos <= stop);
1436 m_pos = pos; //m_pos >= stop is now we know we have all clusters
1437 return (pos >= stop);
1443 long long& pos,
1448 const long result = DoLoadCluster(pos, len);
1457 long long& pos,
1461 return DoLoadClusterUnknownSize(pos, len);
1485 pos = m_pos;
1489 if ((pos + 1) > avail)
1495 long long result = GetUIntLength(m_pReader, pos, len);
1503 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
1506 if ((pos + len) > avail)
1509 const long long idpos = pos;
1515 pos += len; //consume ID
1519 if ((pos + 1) > avail)
1525 result = GetUIntLength(m_pReader, pos, len);
1533 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
1536 if ((pos + len) > avail)
1539 const long long size = ReadUInt(m_pReader, pos, len);
1544 pos += len; //consume length of size of element
1546 //pos now points to start of payload
1550 m_pos = pos;
1563 ((pos + size) > segment_stop))
1571 if ((pos + size) > avail)
1582 const long long element_size = (pos - idpos) + size;
1585 pos,
1592 m_pos = pos + size; //consume payload
1601 m_pos = pos + size; //consume payload
1607 cluster_off = idpos - m_start; //relative pos
1624 pos = pos_;
1635 //pos ptr past the most recent cluster parsed, and then
1654 //because we adjust the pos down to the curr seek pos,
1678 pos += cluster_size;
1686 pos = pCluster->m_element_start + element_size;
1693 m_pos = pos; //consume payload
1705 pos += cluster_size;
1707 if ((total >= 0) && (pos >= total))
1713 if ((segment_stop >= 0) && (pos >= segment_stop))
1719 m_pos = pos;
1738 pos += cluster_size;
1740 m_pos = pos;
1747 m_pos = -pos;
1753 //pos designates start of payload
1760 const long long payload_pos = pos; //absolute pos of cluster payload
1764 if ((total >= 0) && (pos >= total))
1767 if ((segment_stop >= 0) && (pos >= segment_stop))
1772 if ((pos + 1) > avail)
1778 long long result = GetUIntLength(m_pReader, pos, len);
1786 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
1789 if ((pos + len) > avail)
1792 const long long idpos = pos;
1821 pos += len; //consume ID (of sub-element)
1825 if ((pos + 1) > avail)
1831 result = GetUIntLength(m_pReader, pos, len);
1839 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
1842 if ((pos + len) > avail)
1845 const long long size = ReadUInt(m_pReader, pos, len);
1850 pos += len; //consume size field of element
1852 //pos now points to start of sub-element's payload
1862 if ((segment_stop >= 0) && ((pos + size) > segment_stop)) //weird
1865 pos += size; //consume payload of sub-element
1866 assert((segment_stop < 0) || (pos <= segment_stop));
1869 cluster_size = pos - payload_pos;
1872 pos = payload_pos; //reset and re-parse original cluster
1890 m_pos = pos + cluster_size; //consume payload
1901 long long& pos,
1912 pos = -m_pos;
1913 assert(pos > element_start);
1934 if ((total >= 0) && (pos >= total))
1942 if ((segment_stop >= 0) && (pos >= segment_stop))
1952 if ((pos + 1) > avail)
1958 long long result = GetUIntLength(m_pReader, pos, len);
1966 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
1969 if ((pos + len) > avail)
1972 const long long idpos = pos;
1984 element_size = pos - element_start;
2005 pos += len; //consume ID (of sub-element)
2009 if ((pos + 1) > avail)
2015 result = GetUIntLength(m_pReader, pos, len);
2023 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
2026 if ((pos + len) > avail)
2029 const long long size = ReadUInt(m_pReader, pos, len);
2034 pos += len; //consume size field of element
2036 //pos now points to start of sub-element's payload
2046 if ((segment_stop >= 0) && ((pos + size) > segment_stop)) //weird
2049 pos += size; //consume payload of sub-element
2050 assert((segment_stop < 0) || (pos <= segment_stop));
2060 const long status = m_pUnknownSize->Parse(pos, len);
2075 pos = start + size;
2076 m_pos = pos;
2240 //and pos designates start of payload. We need to find the
2256 long long pos = m_pos;
2258 if ((total >= 0) && (pos >= total))
2261 if ((segment_stop >= 0) && (pos >= segment_stop))
2264 const long long element_start = pos;
2268 long long result = GetUIntLength(m_pReader, pos, len);
2273 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
2276 const long long idpos = pos;
2282 pos += len; //consume ID
2285 result = GetUIntLength(m_pReader, pos, len);
2290 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
2293 const long long size = ReadUInt(m_pReader, pos, len);
2303 pos += len; //consume length of size of element
2305 //Pos now points to start of payload
2307 const long long element_size = (pos - element_start) + size;
2309 if ((segment_stop >= 0) && ((pos + size) > segment_stop))
2343 m_pCues = new Cues(this, pos, size, element_start, element_size);
2351 pos,
2362 pos,
2369 m_pos = pos + size; //consume payload
2388 long long pos = start;
2391 while (pos < stop)
2395 const long long id = ReadUInt(m_pReader, pos, len);
2397 assert((pos + len) <= stop);
2399 pos += len; //consume ID
2401 const long long size = ReadUInt(m_pReader, pos, len);
2403 assert((pos + len) <= stop);
2405 pos += len; //consume Size field
2406 assert((pos + size) <= stop);
2409 ParseSeekEntry(pos, size);
2411 pos += size; //consume payload
2412 assert(pos <= stop);
2415 assert(pos == stop);
2432 long long pos = start;
2441 while (pos < stop)
2445 const long long id = ReadUInt(pReader, pos, len);
2447 assert((pos + len) <= stop);
2449 pos += len; //consume ID
2451 const long long size = ReadUInt(pReader, pos, len);
2453 assert((pos + len) <= stop);
2455 pos += len; //consume Size field
2456 assert((pos + size) <= stop);
2461 pos += size; //consume payload
2462 assert(pos <= stop);
2465 assert(pos == stop);
2476 pos = start;
2478 while (pos < stop)
2482 const long long id = ReadUInt(pReader, pos, len);
2484 assert((pos + len) <= stop);
2486 pos += len; //consume ID
2488 const long long size = ReadUInt(pReader, pos, len);
2490 assert((pos + len) <= stop);
2492 pos += len; //consume Size field
2493 assert((pos + size) <= stop);
2496 ParseEntry(pReader, pos, size, pEntry);
2498 pos += size; //consume payload
2499 assert(pos <= stop);
2502 assert(pos == stop);
2543 long long pos = m_start + off;
2544 const long long element_start = pos;
2549 long long result = GetUIntLength(m_pReader, pos, len);
2551 assert((pos + len) <= stop);
2553 const long long idpos = pos;
2558 pos += len; //consume ID
2559 assert(pos < stop);
2563 result = GetUIntLength(m_pReader, pos, len);
2565 assert((pos + len) <= stop);
2567 const long long size = ReadUInt(m_pReader, pos, len);
2570 pos += len; //consume length of size of element
2571 assert((pos + size) <= stop);
2573 const long long element_size = size + pos - element_start;
2575 //Pos now points to start of payload
2577 m_pCues = new Cues(this, pos, size, element_start, element_size);
2585 long long& pos,
2603 pos = m_start + off;
2605 if ((total < 0) || (pos >= total))
2608 const long long element_start = pos;
2611 if ((pos + 1) > avail)
2617 long long result = GetUIntLength(m_pReader, pos, len);
2628 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
2631 if ((pos + len) > avail)
2634 const long long idpos = pos;
2641 pos += len; //consume ID
2642 assert((segment_stop < 0) || (pos <= segment_stop));
2646 if ((pos + 1) > avail)
2652 result = GetUIntLength(m_pReader, pos, len);
2663 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
2666 if ((pos + len) > avail)
2669 const long long size = ReadUInt(m_pReader, pos, len);
2677 pos += len; //consume length of size of element
2678 assert((segment_stop < 0) || (pos <= segment_stop));
2680 //Pos now points to start of payload
2682 pos + size;
2699 pos,
2715 long long pos = start;
2721 const long long seekIdId = ReadUInt(m_pReader, pos, len);
2724 assert((pos + len) <= stop);
2726 pos += len; //consume id
2728 const long long seekIdSize = ReadUInt(m_pReader, pos, len);
2730 assert((pos + len) <= stop);
2732 pos += len; //consume size
2734 const long long seekId = ReadUInt(m_pReader, pos, len); //payload
2737 assert((pos + len) <= stop);
2739 pos += seekIdSize; //consume payload
2741 const long long seekPosId = ReadUInt(m_pReader, pos, len);
2744 assert((pos + len) <= stop);
2746 pos += len; //consume id
2748 const long long seekPosSize = ReadUInt(m_pReader, pos, len);
2750 assert((pos + len) <= stop);
2752 pos += len; //consume size
2753 assert((pos + seekPosSize) <= stop);
2755 const long long seekOff = UnserializeUInt(m_pReader, pos, seekPosSize);
2759 pos += seekPosSize; //consume payload
2760 assert(pos == stop);
2775 long long pos = start;
2782 const long long seekIdId = ReadUInt(pReader, pos, len);
2788 if ((pos + len) > stop)
2791 pos += len; //consume SeekID id
2793 const long long seekIdSize = ReadUInt(pReader, pos, len);
2798 if ((pos + len) > stop)
2801 pos += len; //consume size of field
2803 if ((pos + seekIdSize) > stop)
2811 pEntry->id = ReadUInt(pReader, pos, len); //payload
2819 pos += seekIdSize; //consume SeekID payload
2821 const long long seekPosId = ReadUInt(pReader, pos, len);
2826 if ((pos + len) > stop)
2829 pos += len; //consume id
2831 const long long seekPosSize = ReadUInt(pReader, pos, len);
2836 if ((pos + len) > stop)
2839 pos += len; //consume size
2841 if ((pos + seekPosSize) > stop)
2844 pEntry->pos = UnserializeUInt(pReader, pos, seekPosSize);
2846 if (pEntry->pos < 0)
2849 pos += seekPosSize; //consume payload
2851 if (pos != stop)
2924 long long pos = m_start;
2928 while (pos < stop)
2930 const long long idpos = pos;
2934 const long long id = ReadUInt(pReader, pos, len);
2936 assert((pos + len) <= stop);
2938 pos += len; //consume ID
2940 const long long size = ReadUInt(pReader, pos, len);
2942 assert((pos + len) <= stop);
2944 pos += len; //consume Size field
2945 assert((pos + size) <= stop);
2950 pos += size; //consume payload
2951 assert(pos <= stop);
2958 long long pos) const
3003 CuePoint* const pCP = new CuePoint(m_preload_count, pos);
3420 //const long long pos = pos_ * ((pos_ < 0) ? -1 : 1);
3422 const long long pos = pCluster->GetPosition();
3423 assert(pos >= 0);
3425 if (pos < tp.m_pos)
3427 else if (pos > tp.m_pos)
3478 //const long long pos = pos_ * ((pos_ < 0) ? -1 : 1);
3480 const long long pos = pCluster->GetPosition();
3481 assert(pos >= 0);
3483 if (pos < requested_pos)
3485 else if (pos > requested_pos)
3512 CuePoint::CuePoint(long idx, long long pos) :
3516 m_timecode(-1 * pos),
3520 assert(pos > 0);
3551 //assert((pos + len) <= stop);
3557 //assert((pos + len) <= stop);
3560 //assert((pos + size) <= stop);
3569 long long pos = pos_;
3573 while (pos < stop)
3577 const long long id = ReadUInt(pReader, pos, len);
3579 assert((pos + len) <= stop);
3581 pos += len; //consume ID
3583 const long long size = ReadUInt(pReader, pos, len);
3585 assert((pos + len) <= stop);
3587 pos += len; //consume Size field
3588 assert((pos + size) <= stop);
3591 m_timecode = UnserializeUInt(pReader, pos, size);
3596 pos += size; //consume payload
3597 assert(pos <= stop);
3612 pos = pos_;
3614 while (pos < stop)
3618 const long long id = ReadUInt(pReader, pos, len);
3620 assert((pos + len) <= stop);
3622 pos += len; //consume ID
3624 const long long size = ReadUInt(pReader, pos, len);
3626 assert((pos + len) <= stop);
3628 pos += len; //consume Size field
3629 assert((pos + size) <= stop);
3634 tp.Parse(pReader, pos, size);
3637 pos += size; //consume payload
3638 assert(pos <= stop);
3655 long long pos = start_;
3661 while (pos < stop)
3665 const long long id = ReadUInt(pReader, pos, len);
3667 assert((pos + len) <= stop);
3669 pos += len; //consume ID
3671 const long long size = ReadUInt(pReader, pos, len);
3673 assert((pos + len) <= stop);
3675 pos += len; //consume Size field
3676 assert((pos + size) <= stop);
3679 m_track = UnserializeUInt(pReader, pos, size);
3682 m_pos = UnserializeUInt(pReader, pos, size);
3685 m_block = UnserializeUInt(pReader, pos, size);
3687 pos += size; //consume payload
3688 assert(pos <= stop);
3817 //long long pos = m_start + off;
3819 long long pos = pCurr->m_element_start;
3827 long long result = GetUIntLength(m_pReader, pos, len);
3829 assert((pos + len) <= stop); //TODO
3831 const long long id = ReadUInt(m_pReader, pos, len);
3834 pos += len; //consume ID
3837 result = GetUIntLength(m_pReader, pos, len);
3839 assert((pos + len) <= stop); //TODO
3841 const long long size = ReadUInt(m_pReader, pos, len);
3845 pos += len; //consume length of size of element
3846 assert((pos + size) <= stop); //TODO
3848 //Pos now points to start of payload
3850 pos += size; //consume payload
3857 while (pos < stop)
3861 long long result = GetUIntLength(m_pReader, pos, len);
3863 assert((pos + len) <= stop); //TODO
3865 const long long idpos = pos; //pos of next (potential) cluster
3870 pos += len; //consume ID
3873 result = GetUIntLength(m_pReader, pos, len);
3875 assert((pos + len) <= stop); //TODO
3877 const long long size = ReadUInt(m_pReader, pos, len);
3880 pos += len; //consume length of size of element
3881 assert((pos + size) <= stop); //TODO
3883 const long long element_size = size + pos - idpos;
3885 //Pos now points to start of payload
3914 pos += size; //consume payload
3942 //pos = pos_ * ((pos_ < 0) ? -1 : 1);
3944 pos = pNext->GetPosition();
3946 if (pos < off_next)
3948 else if (pos > off_next)
3976 long long& pos,
3999 const long result = LoadCluster(pos, len);
4029 pos = pCurr->m_element_start;
4032 pos += pCurr->m_element_size;
4035 if ((pos + 1) > avail)
4041 long long result = GetUIntLength(m_pReader, pos, len);
4049 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
4052 if ((pos + len) > avail)
4055 const long long id = ReadUInt(m_pReader, pos, len);
4060 pos += len; //consume ID
4064 if ((pos + 1) > avail)
4070 result = GetUIntLength(m_pReader, pos, len);
4078 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
4081 if ((pos + len) > avail)
4084 const long long size = ReadUInt(m_pReader, pos, len);
4089 pos += len; //consume size field
4098 if ((segment_stop >= 0) && ((pos + size) > segment_stop))
4101 //Pos now points to start of payload
4103 pos += size; //consume payload (that is, the current cluster)
4104 assert((segment_stop < 0) || (pos <= segment_stop));
4114 //pos now points to just beyond the last fully-loaded cluster
4118 const long status = DoParseNext(pResult, pos, len);
4128 long long& pos,
4151 if ((total >= 0) && (pos >= total))
4154 if ((segment_stop >= 0) && (pos >= segment_stop))
4157 if ((pos + 1) > avail)
4163 long long result = GetUIntLength(m_pReader, pos, len);
4171 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
4174 if ((pos + len) > avail)
4177 const long long idpos = pos; //absolute
4178 const long long idoff = pos - m_start; //relative
4188 pos += len; //consume ID
4192 if ((pos + 1) > avail)
4198 result = GetUIntLength(m_pReader, pos, len);
4206 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
4209 if ((pos + len) > avail)
4212 const long long size = ReadUInt(m_pReader, pos, len);
4217 pos += len; //consume length of size of element
4219 //Pos now points to start of payload
4228 ((pos + size) > segment_stop))
4238 const long long element_stop = pos + size;
4249 pos,
4256 pos += size; //consume payload
4257 assert((segment_stop < 0) || (pos <= segment_stop));
4267 pos += size; //consume payload
4268 assert((segment_stop < 0) || (pos <= segment_stop));
4318 pos = pNext->GetPosition();
4319 assert(pos >= 0);
4321 if (pos < off_next)
4323 else if (pos > off_next)
4341 pos = pos_;
4370 const long long payload_pos = pos; //absolute pos of cluster payload
4374 if ((total >= 0) && (pos >= total))
4377 if ((segment_stop >= 0) && (pos >= segment_stop))
4382 if ((pos + 1) > avail)
4388 long long result = GetUIntLength(m_pReader, pos, len);
4396 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
4399 if ((pos + len) > avail)
4402 const long long idpos = pos;
4418 pos += len; //consume ID (of sub-element)
4422 if ((pos + 1) > avail)
4428 result = GetUIntLength(m_pReader, pos, len);
4436 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
4439 if ((pos + len) > avail)
4442 const long long size = ReadUInt(m_pReader, pos, len);
4447 pos += len; //consume size field of element
4449 //pos now points to start of sub-element's payload
4459 if ((segment_stop >= 0) && ((pos + size) > segment_stop)) //weird
4462 pos += size; //consume payload of sub-element
4463 assert((segment_stop < 0) || (pos <= segment_stop));
4466 cluster_size = pos - payload_pos;
4469 pos = payload_pos; //reset and re-parse original cluster
4472 pos += cluster_size; //consume payload
4473 assert((segment_stop < 0) || (pos <= segment_stop));
4762 long long pos = start;
4768 while (pos < stop)
4770 if (Match(pReader, pos, 0x0AD7B1, m_timecodeScale))
4773 else if (Match(pReader, pos, 0x0489, m_duration))
4776 else if (Match(pReader, pos, 0x0D80, m_pMuxingAppAsUTF8)) //[4D][80]
4779 else if (Match(pReader, pos, 0x1741, m_pWritingAppAsUTF8)) //[57][41]
4782 else if (Match(pReader, pos, 0x3BA9, m_pTitleAsUTF8)) //[7B][A9]
4789 const long long id = ReadUInt(pReader, pos, len);
4792 assert((pos + len) <= stop);
4794 pos += len; //consume id
4795 assert((stop - pos) > 0);
4797 const long long size = ReadUInt(pReader, pos, len);
4799 assert((pos + len) <= stop);
4801 pos += len + size; //consume size and payload
4802 assert(pos <= stop);
4806 assert(pos == stop);
5161 long long pos = s.start;
5162 assert(pos >= 0);
5164 const long long stop = pos + s.size;
5166 while (pos < stop)
5170 const long long id = ReadUInt(pReader, pos, len);
5172 assert((pos + len) <= stop);
5174 if (Match(pReader, pos, 0x30, m_width))
5176 else if (Match(pReader, pos, 0x3A, m_height))
5178 else if (Match(pReader, pos, 0x0383E3, m_rate))
5183 const long long id = ReadUInt(pReader, pos, len);
5185 assert((pos + len) <= stop);
5187 pos += len; //consume id
5189 const long long size = ReadUInt(pReader, pos, len);
5191 assert((pos + len) <= stop);
5193 pos += len; //consume length of size
5194 assert((pos + size) <= stop);
5196 //pos now designates start of payload
5198 pos += size; //consume payload
5199 assert(pos <= stop);
5356 long long pos = s.start;
5357 assert(pos >= 0);
5359 const long long stop = pos + s.size;
5361 while (pos < stop)
5365 const long long id = ReadUInt(pReader, pos, len);
5367 assert((pos + len) <= stop);
5369 if (Match(pReader, pos, 0x35, m_rate))
5371 else if (Match(pReader, pos, 0x1F, m_channels))
5373 else if (Match(pReader, pos, 0x2264, m_bitDepth))
5378 const long long id = ReadUInt(pReader, pos, len);
5380 assert((pos + len) <= stop);
5382 pos += len; //consume id
5384 const long long size = ReadUInt(pReader, pos, len);
5386 assert((pos + len) <= stop);
5388 pos += len; //consume length of size
5389 assert((pos + size) <= stop);
5391 //pos now designates start of payload
5393 pos += size; //consume payload
5394 assert(pos <= stop);
5553 //pos now desinates start of element
5567 long long pos = m_start;
5569 while (pos < stop)
5572 const long long id = ReadUInt(pReader, pos, len);
5574 assert((pos + len) <= stop);
5576 const long long element_start = pos;
5578 pos += len; //consume id
5580 const long long size1 = ReadUInt(pReader, pos, len);
5582 assert((pos + len) <= stop);
5584 pos += len; //consume length of size
5586 //pos now desinates start of element
5588 const long long element_size = size1 + pos - element_start;
5593 ParseTrackEntry(pos, size1, pTrack, element_start, element_size);
5599 pos += size1; //consume payload
5600 assert(pos <= stop);
5623 long long pos = start;
5636 while (pos < stop)
5640 const long long id = ReadUInt(pReader, pos, len);
5644 if (Match(pReader, pos, 0x57, i.number))
5646 //else if (Match(pReader, pos, 0x33C5, i.uid))
5648 else if (Match(pReader, pos, 0x03, i.type))
5650 else if (Match(pReader, pos, 0x136E, i.nameAsUTF8))
5652 else if (Match(pReader, pos, 0x06, i.codecId))
5654 else if (Match(pReader, pos, 0x1C, lacing))
5657 pos,
5662 else if (Match(pReader, pos, 0x058688, i.codecNameAsUTF8))
5668 const long long idpos = pos;
5671 const long long id = ReadUInt(pReader, pos, len);
5673 assert((pos + len) <= stop);
5675 pos += len; //consume id
5677 const long long size = ReadUInt(pReader, pos, len);
5679 assert((pos + len) <= stop);
5681 pos += len; //consume length of size
5682 const long long start = pos;
5684 pos += size; //consume payload
5685 assert(pos <= stop);
5721 assert(pos == stop);
5916 long Cluster::Load(long long& pos, long& len) const
5939 pos = m_pos;
5944 if ((pos + 1) > avail)
5950 long long result = GetUIntLength(pReader, pos, len);
5958 //if ((pos + len) > segment_stop)
5961 if ((pos + len) > avail)
5964 const long long id_ = ReadUInt(pReader, pos, len);
5972 pos += len; //consume id
5976 if ((pos + 1) > avail)
5982 result = GetUIntLength(pReader, pos, len);
5990 //if ((pos + len) > segment_stop)
5993 if ((pos + len) > avail)
5996 const long long size = ReadUInt(pReader, pos, len);
6004 pos += len; //consume length of size of element
6012 //pos points to start of payload
6025 long long cluster_stop = (cluster_size < 0) ? -1 : pos + cluster_size;
6029 if ((cluster_stop >= 0) && (pos >= cluster_stop))
6034 if ((pos + 1) > avail)
6040 long long result = GetUIntLength(pReader, pos, len);
6048 if ((cluster_stop >= 0) && ((pos + len) > cluster_stop))
6051 if ((pos + len) > avail)
6054 const long long id = ReadUInt(pReader, pos, len);
6072 pos += len; //consume ID field
6076 if ((pos + 1) > avail)
6082 result = GetUIntLength(pReader, pos, len);
6090 if ((cluster_stop >= 0) && ((pos + len) > cluster_stop))
6093 if ((pos + len) > avail)
6096 const long long size = ReadUInt(pReader, pos, len);
6106 pos += len; //consume size field
6108 if ((cluster_stop >= 0) && (pos > cluster_stop))
6111 //pos now points to start of payload
6116 if ((cluster_stop >= 0) && ((pos + size) > cluster_stop))
6123 if ((pos + size) > avail)
6126 timecode = UnserializeUInt(pReader, pos
6131 new_pos = pos + size;
6147 pos += size; //consume payload
6148 assert((cluster_stop < 0) || (pos <= cluster_stop));
6151 assert((cluster_stop < 0) || (pos <= cluster_stop));
6169 long Cluster::Parse(long long& pos, long& len) const
6171 long status = Load(pos, len);
6198 pos = m_pos;
6202 if ((cluster_stop >= 0) && (pos >= cluster_stop))
6205 if ((total >= 0) && (pos >= total))
6208 m_element_size = pos - m_element_start;
6215 if ((pos + 1) > avail)
6221 long long result = GetUIntLength(pReader, pos, len);
6229 if ((cluster_stop >= 0) && ((pos + len) > cluster_stop))
6232 if ((pos + len) > avail)
6235 const long long id = ReadUInt(pReader, pos, len);
6250 m_element_size = pos - m_element_start;
6255 pos += len; //consume ID field
6259 if ((pos + 1) > avail)
6265 result = GetUIntLength(pReader, pos, len);
6273 if ((cluster_stop >= 0) && ((pos + len) > cluster_stop))
6276 if ((pos + len) > avail)
6279 const long long size = ReadUInt(pReader, pos, len);
6289 pos += len; //consume size field
6291 if ((cluster_stop >= 0) && (pos > cluster_stop))
6294 //pos now points to start of payload
6299 //const long long block_start = pos;
6300 const long long block_stop = pos + size;
6310 pos = total;
6320 return ParseBlockGroup(size, pos, len);
6323 return ParseSimpleBlock(size, pos, len);
6325 pos += size; //consume payload
6326 assert((cluster_stop < 0) || (pos <= cluster_stop));
6331 m_pos = pos;
6364 long long& pos,
6367 const long long block_start = pos;
6368 const long long block_stop = pos + block_size;
6383 if ((pos + 1) > avail)
6389 long long result = GetUIntLength(pReader, pos, len);
6397 if ((pos + len) > block_stop)
6400 if ((pos + len) > avail)
6403 const long long track = ReadUInt(pReader, pos, len);
6421 pos += len; //consume track number
6423 if ((pos + 2) > block_stop)
6426 if ((pos + 2) > avail)
6432 pos += 2; //consume timecode
6434 if ((pos + 1) > block_stop)
6437 if ((pos + 1) > avail)
6445 status = pReader->Read(pos, 1, &flags);
6453 ++pos; //consume flags byte
6454 assert(pos <= avail);
6456 if (pos >= block_stop)
6463 len = static_cast<long>(block_stop - pos);
6476 long long& pos,
6479 const long long payload_start = pos;
6480 const long long payload_stop = pos + payload_size;
6502 while (pos < payload_stop)
6506 if ((pos + 1) > avail)
6512 long long result = GetUIntLength(pReader, pos, len);
6520 if ((pos + len) > payload_stop)
6523 if ((pos + len) > avail)
6526 const long long id = ReadUInt(pReader, pos, len);
6534 pos += len; //consume ID field
6538 if ((pos + 1) > avail)
6544 result = GetUIntLength(pReader, pos, len);
6552 if ((pos + len) > payload_stop)
6555 if ((pos + len) > avail)
6558 const long long size = ReadUInt(pReader, pos, len);
6563 pos += len; //consume size field
6565 //pos now points to start of sub-block group payload
6567 if (pos > payload_stop)
6580 pos += size; //consume sub-part of block group
6582 if (pos > payload_stop)
6588 const long long block_stop = pos + size;
6595 if ((pos + 1) > avail)
6601 result = GetUIntLength(pReader, pos, len);
6609 if ((pos + len) > block_stop)
6612 if ((pos + len) > avail)
6615 const long long track = ReadUInt(pReader, pos, len);
6635 pos += len; //consume track number
6637 if ((pos + 2) > block_stop)
6640 if ((pos + 2) > avail)
6646 pos += 2; //consume timecode
6648 if ((pos + 1) > block_stop)
6651 if ((pos + 1) > avail)
6659 status = pReader->Read(pos, 1, &flags);
6667 ++pos; //consume flags byte
6668 assert(pos <= avail);
6670 if (pos >= block_stop)
6677 len = static_cast<long>(block_stop - pos);
6681 pos = block_stop; //consume block-part of block group
6682 assert(pos <= payload_stop);
6685 assert(pos == payload_stop);
6819 const long long pos = m_element_start - m_pSegment->m_start;
6820 assert(pos >= 0);
6822 return pos;
6842 long long pos = pSegment->m_start + off; //absolute
6848 const long long id = ReadUInt(pReader, pos, len);
6853 pos += len; //consume id
6855 size = ReadUInt(pReader, pos, len);
6858 pos += len; //consume size
6860 //pos now points to start of payload
6863 const long long stop = pos + size;
6865 while (pos < stop)
6869 const long long id = ReadUInt(pReader, pos, len);
6871 assert((pos + len) <= stop);
6873 pos += len; //consume id
6875 const long long size = ReadUInt(pReader, pos, len);
6877 assert((pos + len) <= stop);
6879 pos += len; //consume size
6887 pos += size; //consume payload
6888 assert(pos <= stop);
6899 long long& pos,
6916 pos = pSegment->m_start + off; //absolute
6918 if ((total >= 0) && (pos >= total))
6927 if ((pos + 1) > avail)
6933 long long result = GetUIntLength(pReader, pos, len);
6941 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
6944 if ((total >= 0) && ((pos + len) > total))
6947 if ((pos + len) > avail)
6950 const long long id = ReadUInt(pReader, pos, len);
6958 pos += len; //consume Cluster ID field
6962 if ((pos + 1) > avail)
6968 result = GetUIntLength(pReader, pos, len);
6976 if ((segment_stop >= 0) && ((pos + len) > segment_stop))
6979 if ((total >= 0) && ((pos + len) > total))
6982 if ((pos + len) > avail)
6985 const long long size = ReadUInt(pReader, pos, len);
6993 pos += len; //consume size field
6995 //pos now points to start of payload
7001 cluster_stop = pos + size;
7015 if ((cluster_stop >= 0) && (pos >= cluster_stop))
7018 if ((pos + 1) > avail)
7024 long long result = GetUIntLength(pReader, pos, len);
7032 if ((cluster_stop >= 0) && ((pos + len) > cluster_stop))
7035 if ((pos + len) > avail)
7038 const long long id = ReadUInt(pReader, pos, len);
7053 pos += len; //consume id field
7055 if ((cluster_stop >= 0) && (pos >= cluster_stop))
7060 if ((pos + 1) > avail)
7066 result = GetUIntLength(pReader, pos, len);
7074 if ((cluster_stop >= 0) && ((pos + len) > cluster_stop))
7077 if ((pos + len) > avail)
7080 const long long size = ReadUInt(pReader, pos, len);
7085 pos += len; //consume size field
7087 //pos now points to start of payload
7089 if ((cluster_stop >= 0) && (pos > cluster_stop))
7100 if ((cluster_stop >= 0) && ((pos + size) > cluster_stop))
7109 pos += size; //consume payload
7110 assert((cluster_stop < 0) || (pos <= cluster_stop));
7136 //long long pos = m_pSegment->m_start + m_pos; //absolute
7182 long long pos = m_pos;
7185 while (pos < cluster_stop)
7187 if (Match(pReader, pos, 0x67, timecode))
7198 const long long id = ReadUInt(pReader, pos, len);
7200 assert((pos + len) <= cluster_stop);
7202 pos += len; //consume id
7204 const long long size = ReadUInt(pReader, pos, len);
7206 assert((pos + len) <= cluster_stop);
7208 pos += len; //consume size
7215 pos += size; //consume payload
7216 assert(pos <= cluster_stop);
7220 assert(pos == cluster_stop);
7225 m_pos = pos;
7362 long long pos, //absolute pos of payload
7411 CreateBlockGroup(pos, size, ppEntry);
7415 CreateSimpleBlock(pos, size, ppEntry);
7767 long long pos = start;
7773 while (pos < stop)
7777 if (Match(pReader, pos, 0x7B, t))
7791 const long long id = ReadUInt(pReader, pos, len);
7793 assert((pos + len) <= stop);
7795 pos += len; //consume ID
7797 const long long size = ReadUInt(pReader, pos, len);
7799 assert((pos + len) <= stop);
7801 pos += len; //consume size
7810 ParseBlock(pos, size);
7817 pos += size; //consume payload
7818 assert(pos <= stop);
7822 assert(pos == stop);
7897 long long pos = start;
7902 m_track = ReadUInt(pReader, pos, len);
7904 assert((pos + len) <= stop);
7906 pos += len; //consume track number
7907 assert((stop - pos) >= 2);
7909 m_timecode = Unserialize2SInt(pReader, pos);
7911 pos += 2;
7912 assert((stop - pos) >= 1);
7914 long status = pReader->Read(pos, 1, &m_flags);
7925 ++pos; //consume flags byte
7926 assert(pos <= stop);
7934 f.pos = pos;
7936 const long long frame_size = stop - pos;
7944 assert(pos < stop);
7948 status = pReader->Read(pos, 1, &count);
7951 ++pos; //consume frame count
7952 assert(pos <= stop);
7972 status = pReader->Read(pos, 1, &val);
7975 ++pos; //consume xiph size byte
7993 assert(pos < stop);
7999 const long long total_size = stop - pos;
8012 assert((pos + f.len) <= stop);
8014 f.pos = pos;
8015 pos += f.len;
8018 assert(pos == stop);
8022 const long long total_size = stop - pos;
8033 assert((pos + frame_size) <= stop);
8037 f.pos = pos;
8040 pos += frame_size;
8043 assert(pos == stop);
8048 assert(pos < stop);
8052 long long frame_size = ReadUInt(pReader, pos, len);
8055 assert((pos + len) <= stop);
8057 pos += len; //consume length of size of first frame
8058 assert((pos + frame_size) <= stop);
8074 assert(pos < stop);
8083 const long long delta_size_ = ReadUInt(pReader, pos, len);
8085 assert((pos + len) <= stop);
8087 pos += len; //consume length of (delta) size
8088 assert(pos <= stop);
8105 assert(pos < stop);
8115 const long long total_size = stop - pos;
8130 assert((pos + f.len) <= stop);
8132 f.pos = pos;
8133 pos += f.len;
8136 assert(pos == stop);
8219 assert(f.pos > 0);
8231 const long status = pReader->Read(pos, len, buf);
