Home | History | Annotate | Download | only in mkvparser

Lines Matching full:preader

27 long long mkvparser::ReadUInt(IMkvReader* pReader, long long pos, long& len)

29     assert(pReader);

36 //    status = pReader->Length(&total, &available);

47     status = pReader->Read(pos, 1, &b);

75         status = pReader->Read(pos, 1, &b);

99     IMkvReader* pReader,

103     assert(pReader);

108     int status = pReader->Length(&total, &available);

119     status = pReader->Read(pos, 1, &b);

141     IMkvReader* pReader,

146     assert(pReader);

153     long hr = pReader->Read(pos, 1, &b);

181         hr = pReader->Read(pos, 1, &b);

200     IMkvReader* pReader,

204     assert(pReader);

215         const long status = pReader->Read(pos, 1, &b);

231     IMkvReader* pReader,

234     assert(pReader);

241         const long status = pReader->Length(&total, &available);

256         hr = pReader->Read(pos, 1, --q);

277         const int status = pReader->Read(pos++, 1, &b);

296     IMkvReader* pReader,

299     assert(pReader);

310         const long hr = pReader->Read(pos, 1, --q);

331         const int status = pReader->Read(pos++, 1, &b);

349     IMkvReader* pReader,

352     assert(pReader);

359         const long status = pReader->Length(&total, &available);

369     const int status = pReader->Read(pos, 1, &b);

376     IMkvReader* pReader,

379     assert(pReader);

386         const long status = pReader->Length(&total, &available);

401         hr = pReader->Read(pos, 1, --q);

416         const int status = pReader->Read(pos++, 1, &b);

433     IMkvReader* pReader,

438     assert(pReader);

443     const long status = pReader->Length(&total, &available);

449     const long long id = ReadUInt(pReader, pos, len);

460     const long long size = ReadUInt(pReader, pos, len);

469     val = UnserializeUInt(pReader, pos, size);

478     IMkvReader* pReader,

483     assert(pReader);

488     long status = pReader->Length(&total, &available);

494     const long long id = ReadUInt(pReader, pos, len);

505     const long long size_ = ReadUInt(pReader, pos, len);

521         status = pReader->Read(pos + i, 1, (unsigned char*)&c);

537     IMkvReader* pReader,

543     assert(pReader);

548     long status = pReader->Length(&total, &available);

553     const long long id = ReadUInt(pReader, pos, len);

564     const long long size_ = ReadUInt(pReader, pos, len);

578     status = pReader->Read(pos, buflen_, buf);

589     IMkvReader* pReader,

594     assert(pReader);

599     const long status = pReader->Length(&total, &available);

605     const long long id = ReadUInt(pReader, pos, idlen);

612     const long long size = ReadUInt(pReader, pos + idlen, sizelen);

627         val = Unserialize4Float(pReader, pos);

631         val = Unserialize8Double(pReader, pos);

641     IMkvReader* pReader,

646     assert(pReader);

651     const long status = pReader->Length(&total, &available);

656     const long long id = ReadUInt(pReader, pos, len);

665     const long long size = ReadUInt(pReader, pos, len);

675         val = Unserialize1SInt(pReader, pos);

677         val = Unserialize2SInt(pReader, pos);

717     IMkvReader* pReader,

720     assert(pReader);

724     long status = pReader->Length(&total, &available);

738             status = pReader->Read(pos, 1, &b);

768         const long long result = ReadUInt(pReader, pos, len);

787     long long result = GetUIntLength(pReader, pos, len);

806     result = ReadUInt(pReader, pos, len);

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);

851             result = ReadUInt(pReader, pos, len);

867     IMkvReader* pReader,

870     m_pReader(pReader),

912     IMkvReader* pReader,

916     assert(pReader);

923     const long status = pReader->Length(&total, &available);

959         long long result = GetUIntLength(pReader, pos, len);

970         const long long id = ReadUInt(pReader, pos, len);

979         result = GetUIntLength(pReader, pos, len);

990         long long size = ReadUInt(pReader, pos, len);

1018             pSegment = new (std::nothrow) Segment(pReader, pos, size);

2435     IMkvReader* const pReader = m_pSegment->m_pReader;

2445         const long long id = ReadUInt(pReader, pos, len);

2451         const long long size = ReadUInt(pReader, pos, len);

2482         const long long id = ReadUInt(pReader, pos, len);

2488         const long long size = ReadUInt(pReader, pos, len);

2496             ParseEntry(pReader, pos, size, pEntry);

2770     IMkvReader* pReader,

2782     const long long seekIdId = ReadUInt(pReader, pos, len);

2793     const long long seekIdSize = ReadUInt(pReader, pos, len);

2811     pEntry->id = ReadUInt(pReader, pos, len);  //payload

2821     const long long seekPosId = ReadUInt(pReader, pos, len);

2831     const long long seekPosSize = ReadUInt(pReader, pos, len);

2844     pEntry->pos = UnserializeUInt(pReader, pos, seekPosSize);

2921     IMkvReader* const pReader = m_pSegment->m_pReader;

2934         const long long id = ReadUInt(pReader, pos, len);

2940         const long long size = ReadUInt(pReader, pos, len);

3020     IMkvReader* const pReader = m_pSegment->m_pReader;

3028         const long long id = ReadUInt(pReader, m_pos, len);

3034         const long long size = ReadUInt(pReader, m_pos, len);

3055         pCP->Load(pReader);

3099     IMkvReader* const pReader = m_pSegment->m_pReader;

3114         pCP->Load(pReader);

3530 void CuePoint::Load(IMkvReader* pReader)

3549         const long long id = ReadUInt(pReader, pos_, len);

3555         const long long size = ReadUInt(pReader, pos_, len);

3577         const long long id = ReadUInt(pReader, pos, len);

3583         const long long size = ReadUInt(pReader, pos, len);

3591             m_timecode = UnserializeUInt(pReader, pos, size);

3618         const long long id = ReadUInt(pReader, pos, len);

3624         const long long size = ReadUInt(pReader, pos, len);

3634             tp.Parse(pReader, pos, size);

3650     IMkvReader* pReader,

3665         const long long id = ReadUInt(pReader, pos, len);

3671         const long long size = ReadUInt(pReader, pos, len);

3679             m_track = UnserializeUInt(pReader, pos, size);

3682             m_pos = UnserializeUInt(pReader, pos, size);

3685             m_block = UnserializeUInt(pReader, pos, size);

4760     IMkvReader* const pReader = m_pSegment->m_pReader;

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);

4797             const long long size = ReadUInt(pReader, pos, len);

5155     IMkvReader* const pReader = pSegment->m_pReader;

5170         const long long id = ReadUInt(pReader, pos, len);

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);

5189             const long long size = ReadUInt(pReader, pos, len);

5350     IMkvReader* const pReader = pSegment->m_pReader;

5365         const long long id = ReadUInt(pReader, pos, len);

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);

5384             const long long size = ReadUInt(pReader, pos, len);

5533     IMkvReader* const pReader = m_pSegment->m_pReader;

5541         const long long id = ReadUInt(pReader, pos1, len);

5547         const long long size = ReadUInt(pReader, pos1, len);

5572         const long long id = ReadUInt(pReader, pos, len);

5580         const long long size1 = ReadUInt(pReader, pos, len);

5621     IMkvReader* const pReader = m_pSegment->m_pReader;

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))

5656         else if (Match(pReader,

5662         else if (Match(pReader, pos, 0x058688, i.codecNameAsUTF8))

5671             const long long id = ReadUInt(pReader, pos, len);

5677             const long long size = ReadUInt(pReader, pos, len);

5709                     const long status = pReader->Read(pos_, 1, &b);

5851     IMkvReader* const pReader = m_pSegment->m_pReader;

5855     const long long id_ = ReadUInt(pReader, m_pos, len);

5861     const long long cluster_size = ReadUInt(pReader, m_pos, len);

5882         if (Match(pReader, m_pos, 0x67, timecode))

5886             const long long id = ReadUInt(pReader, m_pos, len);

5892             const long long size = ReadUInt(pReader, m_pos, len);

5927     IMkvReader* const pReader = m_pSegment->m_pReader;

5931     const int status = pReader->Length(&total, &avail);

5950         long long result = GetUIntLength(pReader, pos, len);

5964         const long long id_ = ReadUInt(pReader, pos, len);

5982         result = GetUIntLength(pReader, pos, len);

5996         const long long size = ReadUInt(pReader, pos, len);

6040         long long result = GetUIntLength(pReader, pos, len);

6054         const long long id = ReadUInt(pReader, pos, len);

6082         result = GetUIntLength(pReader, pos, len);

6096         const long long size = ReadUInt(pReader, pos, len);

6126             timecode = UnserializeUInt(pReader
6187     IMkvReader* const pReader = m_pSegment->m_pReader;

6191     status = pReader->Length(&total, &avail);

6221         long long result = GetUIntLength(pReader, pos, len);

6235         const long long id = ReadUInt(pReader, pos, len);

6265         result = GetUIntLength(pReader, pos, len);

6279         const long long size = ReadUInt(pReader, pos, len);

6370     IMkvReader* const pReader = m_pSegment->m_pReader;

6374     long status = pReader->Length(&total, &avail);

6389     long long result = GetUIntLength(pReader, pos, len);

6403     const long long track = ReadUInt(pReader, pos, len);

6445     status = pReader->Read(pos, 1, &flags);

6482     IMkvReader* const pReader = m_pSegment->m_pReader;

6486     long status = pReader->Length(&total, &avail);

6512         long long result = GetUIntLength(pReader, pos, len);

6526         const long long id = ReadUInt(pReader, pos, len);

6544         result = GetUIntLength(pReader, pos, len);

6558         const long long size = ReadUInt(pReader, pos, len);

6601         result = GetUIntLength(pReader, pos, len);

6615         const long long track = ReadUInt(pReader, pos, len);

6659         status = pReader->Read(pos, 1, &flags);

6840     IMkvReader* const pReader = pSegment->m_pReader;

6848         const long long id = ReadUInt(pReader, pos, len);

6855         size = ReadUInt(pReader, pos, len);

6869         const long long id = ReadUInt(pReader, pos, len);

6875         const long long size = ReadUInt(pReader, pos, len);

6905     IMkvReader* const pReader = pSegment->m_pReader;

6909     long status = pReader->Length(&total, &avail);

6933         long long result = GetUIntLength(pReader, pos, len);

6950         const long long id = ReadUInt(pReader, pos, len);

6968         result = GetUIntLength(pReader, pos, len);

6985         const long long size = ReadUInt(pReader, pos, len);

7024         long long result = GetUIntLength(pReader, pos, len);

7038         const long long id = ReadUInt(pReader, pos, len);

7066         result = GetUIntLength(pReader, pos, len);

7080         const long long size = ReadUInt(pReader, pos, len);

7132     IMkvReader* const pReader = m_pSegment->m_pReader;

7144         const long long id = ReadUInt(pReader, m_pos, len);

7151         const long long cluster_size = ReadUInt(pReader, m_pos, len);

7187         if (Match(pReader, pos, 0x67, timecode))

7198             const long long id = ReadUInt(pReader, pos, len);

7204             const long long size = ReadUInt(pReader, pos, len);

7281         const long long id = ReadUInt(pReader, m_pos, len);

7287         const long long size = ReadUInt(pReader, m_pos, len);

7765     IMkvReader* const pReader = m_pCluster->m_pSegment->m_pReader;

7777         if (Match(pReader, pos, 0x7B, t))

7791             const long long id = ReadUInt(pReader, pos, len);

7797             const long long size = ReadUInt(pReader, pos, len);

7838     IMkvReader* const pReader = m_pCluster->m_pSegment->m_pReader;

7840     Block* const pBlock = new Block(start, size, pReader);

7893 Block::Block(long long start, long long size_, IMkvReader* pReader) :

7902     m_track = ReadUInt(pReader, pos, len);

7909     m_timecode = Unserialize2SInt(pReader, pos);

7914     long status = pReader->Read(pos, 1, &m_flags);

7948     status = pReader->Read(pos, 1, &count);

7972                 status = pReader->Read(pos, 1, &val);

8052         long long frame_size = ReadUInt(pReader, pos, len);

8083             const long long delta_size_ = ReadUInt(pReader, pos, len);

8226 long Block::Frame::Read(IMkvReader* pReader, unsigned char* buf) const

8228     assert(pReader);

8231     const long status = pReader->Read(pos, len, buf);