Home | History | Annotate | Download | only in mkvparser

Lines Matching refs: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);

142     IMkvReader* pReader,

146     assert(pReader);

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

174     IMkvReader* pReader,

179     assert(pReader);

189     const int status = pReader->Read(pos, size, buf);

246     IMkvReader* pReader,

251     assert(pReader);

259         const long status = pReader->Read(pos, 1, (unsigned char*)&b);

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

289     IMkvReader* pReader,

309     const long status = pReader->Read(pos, size, buf);

326     IMkvReader* pReader,

337     id = ReadUInt(pReader, pos, len);

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

364     IMkvReader* pReader,

369     assert(pReader);

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

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

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

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

409     IMkvReader* pReader,

415     assert(pReader);

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

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

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

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

492     IMkvReader* pReader,

495     assert(pReader);

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

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

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

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

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

605                     pReader,

619             m_version = UnserializeUInt(pReader, pos, size);

626             m_readVersion = UnserializeUInt(pReader, pos, size);

633             m_maxIdLength = UnserializeUInt(pReader, pos, size);

640             m_maxSizeLength = UnserializeUInt(pReader, pos, size);

650             status = UnserializeString(pReader, pos, size, m_docType);

657             m_docTypeVersion = UnserializeUInt(pReader, pos, size);

664             m_docTypeReadVersion = UnserializeUInt(pReader, pos, size);

679     IMkvReader* pReader,

684     m_pReader(pReader),

728     IMkvReader* pReader,

732     assert(pReader);

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

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

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

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

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

831                                             pReader,

1861     IMkvReader* const pReader = m_pSegment->m_pReader;

1876                                 pReader,

1920                                 pReader,

1931             if (ParseEntry(pReader, pos, size, pEntry))

2238     IMkvReader* pReader,

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

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

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

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

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

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

2398     IMkvReader* const pReader = m_pSegment->m_pReader;

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

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

2475     IMkvReader* const pReader = m_pSegment->m_pReader;

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

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

2510         pCP->Load(pReader);

2555     IMkvReader* const pReader = m_pSegment->m_pReader;

2570         pCP->Load(pReader);

2986 void CuePoint::Load(IMkvReader* pReader)

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

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

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

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

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

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

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

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

3106     IMkvReader* pReader,

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

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

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

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

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

4261     IMkvReader* const pReader = m_pSegment->m_pReader;

4274                                 pReader,

4285             m_timecodeScale = UnserializeUInt(pReader, pos, size);

4293                                     pReader,

4307                                     pReader,

4318                                     pReader,

4329                                     pReader,

4484     IMkvReader* const pReader,

4486   assert(pReader);

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

4504     if (Match(pReader, pos, 0x7E1, value)) {

4507     } else if (Match(pReader, pos, 0x7E2, buf, buf_len)) {

4511     } else if (Match(pReader, pos, 0x7E3, buf, buf_len)) {

4515     } else if (Match(pReader, pos, 0x7E4, buf, buf_len)) {

4519     } else if (Match(pReader, pos, 0x7E5, value)) {

4522     } else if (Match(pReader, pos, 0x7E6, value)) {

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

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

4548                                                 IMkvReader* const pReader) {

4549   assert(pReader);

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

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

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

4606     if (Match(pReader, pos, 0x1031, value)) {

4609     } else if (Match(pReader, pos, 0x1032, value)) {

4613     } else if (Match(pReader, pos, 0x1033, value)) {

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

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

4640         ParseEncryptionEntry(pos, size, pReader, encryption);

5042   IMkvReader* const pReader = m_pSegment->m_pReader;

5043   assert(pReader);

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

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

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

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

5098       if (!content_encoding->ParseContentEncodingEntry(pos, size1, pReader)) {

5158     IMkvReader* const pReader = pSegment->m_pReader;

5174                                 pReader,

5185             width = UnserializeUInt(pReader, pos, size);

5192             height = UnserializeUInt(pReader, pos, size);

5200                                     pReader,

5392     IMkvReader* const pReader = pSegment->m_pReader;

5412                                 pReader,

5423             status = UnserializeFloat(pReader, pos, size, rate);

5433             channels = UnserializeUInt(pReader, pos, size);

5440             bit_depth = UnserializeUInt(pReader, pos, size);

5606     IMkvReader* const pReader = m_pSegment->m_pReader;

5616                                 pReader,

5656                                 pReader,

5720     IMkvReader* const pReader = m_pSegment->m_pReader;

5750                                 pReader,

5799                 const int status = pReader->Read(pos_, 1, &b);

5812             const long long num = UnserializeUInt(pReader, pos, size);

5821             const long long type = UnserializeUInt(pReader, pos, size);

5831                                     pReader,

5842                                     pReader,

5852             lacing = UnserializeUInt(pReader, pos, size);

5875             const int status = pReader->Read(pos, buflen, buf);

5889                                     pReader,

6049     IMkvReader* const pReader = m_pSegment->m_pReader;

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

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

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

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

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

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

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

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

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

6248             timecode = UnserializeUInt(pReader, pos, size);

6309     IMkvReader* const pReader = m_pSegment->m_pReader;

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

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

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

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

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

6494     IMkvReader* const pReader = m_pSegment->m_pReader;

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

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

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

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

6630     IMkvReader* const pReader = m_pSegment->m_pReader;

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

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

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

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

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

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

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

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

7008     IMkvReader* const pReader = pSegment->m_pReader;

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

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

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

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

7073     IMkvReader* const pReader = pSegment->m_pReader;

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

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

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

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

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

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

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

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

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

7415     IMkvReader* const pReader = m_pSegment->m_pReader;

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

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

7460             duration = UnserializeUInt(pReader, pos, size);

7470             long status = UnserializeInt(pReader, pos, size_, time);

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

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

8189 long Block::Parse(IMkvReader* pReader)

8191     assert(pReader);

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

8219     status = UnserializeInt(pReader, pos, 2, value);

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

8272     status = pReader->Read(pos, 1, &biased_count);

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

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

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

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

8611     assert(pReader);

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