Cross Reference: /external/libvpx/mkvparser/mkvparser.cpp

Lines Matching refs:idx
1259     const long idx = m_clusterCount;

1263         assert(idx < m_clusterSize);

1265         Cluster* const pCluster = m_clusters[idx];

1289             pCluster->m_index = idx;  //move from preloaded to loaded

1326                                               idx,

1333     assert(idx < m_clusterSize);

1334     assert(m_clusters[idx] == pCluster);

1477         assert(idx < m_clusterSize);

1479         Cluster* const pCluster = m_clusters[idx];

1695     const long idx = pCluster->m_index;

1696     assert(idx == m_clusterCount);

1741     m_clusters[idx] = pCluster;

1746 void Segment::PreloadCluster(Cluster* pCluster, ptrdiff_t idx)

1750     assert(idx >= m_clusterCount);

1778     Cluster** const p = m_clusters + idx;

1793     m_clusters[idx] = pCluster;

1974 const SeekHead::Entry* SeekHead::GetEntry(int idx) const

1976     if (idx < 0)

1979     if (idx >= m_entry_count)

1982     return m_entries + idx;

1990 const SeekHead::VoidElement* SeekHead::GetVoidElement(int idx) const

1992     if (idx < 0)

1995     if (idx >= m_void_element_count)

1998     return m_void_elements + idx;

2895     const ptrdiff_t idx = i - m_clusters;

2897     PreloadCluster(pCluster, idx);

2900     assert(m_clusters[idx] == pCluster);

2957     const ptrdiff_t idx = i - m_clusters;

2959     PreloadCluster(pCluster, idx);

2962     assert(m_clusters[idx] == pCluster);

2968 CuePoint::CuePoint(long idx, long long pos) :

2971     m_index(idx),

3251     const long idx = m_clusterCount - 1;

3253     Cluster* const pCluster = m_clusters[idx];

3272     long idx =  pCurr->m_index;

3274     if (idx >= 0)

3277         assert(idx < m_clusterCount);

3278         assert(pCurr == m_clusters[idx]);

3280         ++idx;

3282         if (idx >= m_clusterCount)

3285         Cluster* const pNext = m_clusters[idx];

3288         assert(pNext->m_index == idx);

4446 ContentEncoding::GetCompressionByIndex(unsigned long idx) const {

4450   if (idx >= static_cast<unsigned long>(count))

4453   return compression_entries_[idx];

4464 ContentEncoding::GetEncryptionByIndex(unsigned long idx) const {

4468   if (idx >= static_cast<unsigned long>(count))

4471   return encryption_entries_[idx];

5022 Track::GetContentEncodingByIndex(unsigned long idx) const {

5027   if (idx >= static_cast<unsigned long>(count))

5030   return content_encoding_entries_[idx];

6008 const Track* Tracks::GetTrackByIndex(unsigned long idx) const

6012     if (idx >= static_cast<unsigned long>(count))

6015     return m_trackEntries[idx];

6460         const long idx = m_entries_count - 1;

6462         const BlockEntry* const pLast = m_entries[idx];

6902     long idx,

6912                                           idx,

6937     long idx,

6942     m_index(idx),

7487     const long idx = m_entries_count;

7489     BlockEntry** const ppEntry = m_entries + idx;

7494                                   idx,

7531     const long idx = m_entries_count;

7533     BlockEntry** const ppEntry = m_entries + idx;

7536     pEntry = new (std::nothrow) SimpleBlock(this, idx, st, sz);

7615     const long idx = m_entries_count - 1;

7617     pLast = m_entries[idx];

7632     size_t idx = pCurr->GetIndex();

7633     assert(idx < size_t(m_entries_count));

7634     assert(m_entries[idx] == pCurr);

7636     ++idx;

7638     if (idx >= size_t(m_entries_count))

7659         assert(idx < size_t(m_entries_count));

7662     pNext = m_entries[idx];

7845         const ptrdiff_t idx = i - m_entries;

7846         idx;

8041 BlockEntry::BlockEntry(Cluster* p, long idx) :

8043     m_index(idx)

8073     long idx,

8076     BlockEntry(pCluster, idx),

8102     long idx,

8108     BlockEntry(pCluster, idx),

8596 const Block::Frame& Block::GetFrame(int idx) const

8598     assert(idx >= 0);

8599     assert(idx < m_frame_count);

8601     const Frame& f = m_frames[idx];
OpenGrok
