Lines Matching defs:assert
30 assert(pReader);
31 assert(pos >= 0);
38 // assert(status >= 0);
39 // assert((total < 0) || (available <= total));
40 // assert(pos < available);
41 // assert((available - pos) >= 1); //assume here max u-int len is 8
67 // assert((available - pos) >= len);
97 assert(pReader);
98 assert(pos >= 0);
103 assert(status >= 0);
104 assert((total < 0) || (available <= total));
118 assert(status == 0);
135 assert(pReader);
136 assert(pos >= 0);
162 assert(pReader);
163 assert(pos >= 0);
196 assert(size == 8);
222 assert(pReader);
223 assert(pos >= 0);
224 assert(size > 0);
225 assert(size <= 8);
323 assert(pReader);
324 assert(pos >= 0);
329 assert(status >= 0);
330 assert((total < 0) || (available <= total));
337 assert(id >= 0);
338 assert(len > 0);
339 assert(len <= 8);
340 assert((pos + len) <= available);
348 assert(size >= 0);
349 assert(size <= 8);
350 assert(len > 0);
351 assert(len <= 8);
352 assert((pos + len) <= available);
357 assert(val >= 0);
366 assert(pReader);
367 assert(pos >= 0);
372 assert(status >= 0);
373 assert((total < 0) || (available <= total));
379 assert(id >= 0);
380 assert(len > 0);
381 assert(len <= 8);
382 assert((pos + len) <= available);
390 assert(size_ >= 0);
391 assert(len > 0);
392 assert(len <= 8);
393 assert((pos + len) <= available);
396 assert((pos + size_) <= available);
401 assert(buf); // TODO
404 assert(status == 0); // TODO
434 assert(pReader);
505 assert(len > 0);
506 assert(len <= 8);
589 assert(pos == end);
621 assert(p);
637 assert(pReader);
638 assert(pos >= 0);
766 assert((total < 0) || (available <= total));
769 assert((segment_stop < 0) || (total < 0) || (segment_stop <= total));
770 assert((segment_stop < 0) || (m_pos <= segment_stop));
915 assert((segment_stop < 0) || (m_pos <= segment_stop));
946 assert((total < 0) || (avail <= total));
1053 assert(m_pCues); // TODO
1078 assert(cluster_off >= 0); // have cluster
1124 assert(idx < m_clusterSize);
1127 assert(pCluster);
1128 assert(pCluster->m_index < 0);
1131 assert(off >= 0);
1153 assert((segment_stop < 0) || (m_pos <= segment_stop));
1183 assert(pCluster);
1186 assert(m_clusters);
1187 assert(idx < m_clusterSize);
1188 assert(m_clusters[idx] == pCluster);
1194 assert((segment_stop < 0) || (m_pos <= segment_stop));
1268 assert(false);
1317 assert((segment_stop < 0) || (pos <= segment_stop));
1321 assert(cluster_size >= 0);
1328 assert(idx < m_clusterSize);
1331 assert(pCluster);
1332 assert(pCluster->m_index < 0);
1335 assert(off >= 0);
1342 assert((segment_stop < 0) || (m_pos <= segment_stop));
1350 assert(m_pos < 0);
1351 assert(m_pUnknownSize);
1354 assert(m_pUnknownSize->GetElementSize() < 0); //TODO: verify this
1359 assert(pos > element_start);
1372 assert((total < 0) || (avail <= total));
1382 assert(element_size > 0);
1390 assert(element_size > 0);
1429 assert(element_size > 0);
1444 assert(false);
1494 assert((segment_stop < 0) || (pos <= segment_stop));
1497 assert(element_size >= 0);
1512 assert(status > 0); // nothing left to parse of this cluster
1517 assert(size >= 0);
1529 assert(pCluster);
1530 assert(pCluster->m_index >= 0);
1535 assert(size >= count);
1538 assert(idx == m_clusterCount);
1559 assert(m_clusters);
1562 assert(*p);
1563 assert((*p)->m_index < 0);
1566 assert(q < (m_clusters + size));
1570 assert((*qq)->m_index < 0);
1585 assert(pCluster);
1586 assert(pCluster->m_index < 0);
1587 assert(idx >= m_clusterCount);
1592 assert(size >= count);
1612 assert(m_clusters);
1617 assert(q >= p);
1618 assert(q < (m_clusters + size));
1622 assert((*qq)->m_index < 0);
1633 assert(m_clusters == NULL);
1634 assert(m_clusterSize == 0);
1635 assert(m_clusterCount == 0);
1636 // assert(m_size >= 0);
1650 assert(m_pInfo);
1651 assert(m_pTracks);
1706 assert(pos <= stop);
1709 assert(pos == stop);
1753 assert(pos <= stop);
1756 assert(pos == stop);
1759 assert(count_ >= 0);
1760 assert(count_ <= entry_count);
1765 assert(count_ >= 0);
1766 assert(count_ <= void_element_count);
1813 assert(result == 0);
1814 assert((pos + len) <= stop);
1819 assert(id == 0x0C53BB6B); //Cues ID
1822 assert(pos < stop);
1827 assert(result == 0);
1828 assert((pos + len) <= stop);
1831 assert(size >= 0);
1834 assert((pos + size) <= stop);
1841 assert(m_pCues); //TODO
1860 assert((total < 0) || (avail <= total));
1900 assert((segment_stop < 0) || (pos <= segment_stop));
1935 assert((segment_stop < 0) || (pos <= segment_stop));
1956 assert(m_pCues); // TODO
1975 assert(seekIdId == 0x13AB); //SeekID ID
1976 assert((pos + len) <= stop);
1981 assert(seekIdSize >= 0);
1982 assert((pos + len) <= stop);
1987 assert(seekId >= 0);
1988 assert(len == seekIdSize);
1989 assert((pos + len) <= stop);
1995 assert(seekPosId == 0x13AC); //SeekPos ID
1996 assert((pos + len) <= stop);
2001 assert(seekPosSize >= 0);
2002 assert((pos + len) <= stop);
2005 assert((pos + seekPosSize) <= stop);
2008 assert(seekOff >= 0);
2009 assert(seekOff < m_size);
2012 assert(pos == stop);
2015 assert(seekPos < (m_start + m_size));
2135 assert(pCP);
2159 assert(m_count == 0);
2160 assert(m_preload_count == 0);
2175 assert(id >= 0); // TODO
2176 assert((pos + len) <= stop);
2181 assert(size >= 0);
2182 assert((pos + len) <= stop);
2185 assert((pos + size) <= stop);
2191 assert(pos <= stop);
2196 assert(m_count == 0);
2239 assert(id >= 0); // TODO
2240 assert((m_pos + len) <= stop);
2245 assert(size >= 0);
2246 assert((m_pos + len) <= stop);
2249 assert((m_pos + size) <= stop);
2253 assert(m_pos <= stop);
2258 assert(m_preload_count > 0);
2261 assert(pCP);
2262 assert((pCP->GetTimeCode() >= 0) || (-pCP->GetTimeCode() == idpos));
2271 assert(m_pos <= stop);
2282 assert(time_ns >= 0);
2283 assert(pTrack);
2288 assert(m_cue_points);
2289 assert(m_count > 0);
2298 assert(pCP);
2316 assert(k < jj);
2319 assert(pCP);
2330 assert(i <= j);
2333 assert(i == j);
2334 assert(i <= jj);
2335 assert(i > ii);
2338 assert(pCP);
2339 assert(pCP->GetTime(m_pSegment) <= time_ns);
2354 assert(pCP);
2368 assert(k < jj);
2371 assert(pCP);
2380 assert(i <= j);
2383 assert(i == j);
2384 assert(i <= jj);
2385 assert(i > ii);
2388 assert(pCP);
2389 assert(pCP->GetTime(m_pSegment) <= time_ns);
2417 assert(m_cue_points);
2433 assert(k < jj);
2436 assert(pCP);
2445 assert(i <= j);
2448 assert(i == j);
2449 assert(i <= jj);
2455 assert(pCP);
2456 assert(pCP->GetTime(m_pSegment) > time_ns);
2480 assert(pp);
2483 assert(pCP);
2484 assert(pCP->GetTimeCode() >= 0);
2507 assert(pp);
2510 assert(pCP);
2513 assert(pCP->GetTimeCode() >= 0);
2518 assert(pp);
2521 assert(pCP);
2522 assert(pCP->GetTimeCode() >= 0);
2532 assert(pCurr->GetTimeCode() >= 0);
2533 assert(m_cue_points);
2534 assert(m_count >= 1);
2540 assert(index < count);
2543 assert(pp);
2544 assert(pp[index] == pCurr);
2552 assert(pNext);
2557 assert(index < m_count);
2560 assert(pp);
2561 assert(pp[index] == pCurr);
2569 assert(pNext);
2570 assert(pNext->GetTimeCode() >= 0);
2604 assert(k < jj);
2607 assert(pCluster);
2610 // assert(pos_);
2614 assert(pos >= 0);
2624 assert(i == j);
2625 // assert(Cluster::HasBlockEntries(this, tp.m_pos));
2628 assert(pCluster);
2633 assert(m_clusters);
2634 assert(m_clusterPreloadCount > 0);
2635 assert(m_clusters[idx] == pCluster);
2659 assert(k < jj);
2662 assert(pCluster);
2665 // assert(pos_);
2669 assert(pos >= 0);
2679 assert(i == j);
2680 // assert(Cluster::HasBlockEntries(this, tp.m_pos));
2684 assert(pCluster);
2689 assert(m_clusters);
2690 assert(m_clusterPreloadCount > 0);
2691 assert(m_clusters[idx] == pCluster);
2703 assert(pos > 0);
2715 assert(m_track_positions == NULL);
2716 assert(m_track_positions_count == 0);
2727 assert(id == 0x3B); // CuePoint ID
2734 assert(size >= 0);
2752 assert(id >= 0); // TODO
2753 assert((pos + len) <= stop);
2758 assert(size >= 0);
2759 assert((pos + len) <= stop);
2762 assert((pos + size) <= stop);
2771 assert(pos <= stop);
2774 assert(m_timecode >= 0);
2775 assert(m_track_positions_count > 0);
2792 assert(id >= 0); // TODO
2793 assert((pos + len) <= stop);
2798 assert(size >= 0);
2799 assert((pos + len) <= stop);
2802 assert((pos + size) <= stop);
2810 assert(pos <= stop);
2813 assert(size_t(p - m_track_positions) == m_track_positions_count);
2832 assert(id >= 0); // TODO
2833 assert((pos + len) <= stop);
2838 assert(size >= 0);
2839 assert((pos + len) <= stop);
2842 assert((pos + size) <= stop);
2854 assert(pos <= stop);
2857 assert(m_pos >= 0);
2858 assert(m_track > 0);
2859 // assert(m_block > 0);
2863 assert(pTrack);
2883 assert(pSegment);
2884 assert(m_timecode >= 0);
2887 assert(pInfo);
2890 assert(scale >= 1);
2906 assert(result >= 0);
2937 assert(pCluster);
2949 assert(pCluster);
2957 assert(pCurr);
2958 assert(pCurr != &m_eos);
2959 assert(m_clusters);
2964 assert(m_clusterCount > 0);
2965 assert(idx < m_clusterCount);
2966 assert(pCurr == m_clusters[idx]);
2974 assert(pNext);
2975 assert(pNext->m_index >= 0);
2976 assert(pNext->m_index == idx);
2981 assert(m_clusterPreloadCount > 0);
2985 assert(m_size >= 0); // TODO
2992 assert(result == 0);
2993 assert((pos + len) <= stop); // TODO
2998 assert(id == 0x0F43B675); // Cluster ID
3006 assert(result == 0); // TODO
3007 assert((pos + len) <= stop); // TODO
3010 assert(size > 0); // TODO
3011 // assert((pCurr->m_size <= 0) || (pCurr->m_size == size));
3014 assert((pos + size) <= stop); // TODO
3027 assert(result == 0);
3028 assert((pos + len) <= stop); // TODO
3035 assert(id > 0); // TODO
3041 assert(result == 0); // TODO
3042 assert((pos + len) <= stop); // TODO
3045 assert(size >= 0); // TODO
3048 assert((pos + size) <= stop); // TODO
3063 assert(status >= 0);
3090 assert(k < jj);
3093 assert(pNext);
3094 assert(pNext->m_index < 0);
3097 // assert(pos_);
3110 assert(i == j);
3113 assert(pNext);
3118 assert(m_clusters);
3119 assert(idx_next < m_clusterSize);
3120 assert(m_clusters[idx_next] == pNext);
3127 assert(pCurr);
3128 assert(!pCurr->EOS());
3129 assert(m_clusters);
3134 assert(m_clusters[pCurr->m_index] == pCurr);
3160 assert(m_pos > 0);
3169 assert((total < 0) || (avail <= total));
3239 // assert((pCurr->m_size <= 0) || (pCurr->m_size == size));
3247 assert((segment_stop < 0) || (pos <= segment_stop));
3275 assert((total < 0) || (avail <= total));
3379 assert(m_pCues); // TODO
3383 assert((segment_stop < 0) || (pos <= segment_stop));
3393 assert((segment_stop < 0) || (pos <= segment_stop));
3415 assert(off_next > 0); // have cluster
3436 assert(k < jj);
3439 assert(pNext);
3440 assert(pNext->m_index < 0);
3443 assert(pos >= 0);
3455 assert(i == j);
3474 assert(pNext);
3479 assert(m_clusters);
3480 assert(idx_next < m_clusterSize);
3481 assert(m_clusters[idx_next] == pNext);
3580 assert((segment_stop < 0) || (pos <= segment_stop));
3584 assert(cluster_size >= 0); // TODO: handle cluster_size = 0
3590 assert((segment_stop < 0) || (pos <= segment_stop));
3601 assert(pCluster);
3602 assert(pCluster->m_index == 0);
3620 assert(k < m_clusterCount);
3623 assert(pCluster);
3624 assert(pCluster->m_index == k);
3633 assert(i <= j);
3636 assert(i == j);
3637 assert(i > 0);
3638 assert(i <= m_clusterCount);
3643 assert(pCluster);
3644 assert(pCluster->m_index == k);
3645 assert(pCluster->GetTime() <= time_ns);
3655 assert(pTrack);
3661 assert(i);
3665 assert(pCluster);
3666 assert(pCluster->m_index == 0); //m_clusterCount > 0
3667 assert(pCluster->m_pSegment == this);
3692 assert(mid < hi);
3695 assert(pCluster);
3696 assert(pCluster->m_index == long(mid - m_clusters));
3697 assert(pCluster->m_pSegment == this);
3706 assert(lo <= hi);
3709 assert(lo == hi);
3710 assert(lo > i);
3711 assert(lo <= j);
3716 assert(pCluster);
3717 assert(pCluster->GetTime() <= time_ns);
3730 assert(pTrack->GetType() == 1); //video
3743 assert(mid < hi);
3746 assert(pCluster);
3755 assert(lo <= hi);
3758 assert(lo == hi);
3759 assert(lo > i);
3760 assert(lo <= j);
3763 assert(pCluster);
3764 assert(pCluster->GetTime() <= time_ns);
3778 assert(pCluster);
3779 assert(pCluster->GetTime() <= time_ns);
3812 assert(pCP);
3813 assert(pTP);
3814 assert(pTP->m_track == pTrack->GetNumber());
3835 assert(m_pInfo);
3883 assert(pos <= stop);
3886 assert(pos == stop);
3997 assert(pos <= stop);
4000 assert(pos == stop);
4154 assert(pos <= stop);
4157 assert(pos == stop);
4288 assert(pos <= stop);
4291 assert(pos == stop);
4318 assert(m_pMuxingAppAsUTF8 == NULL);
4319 assert(m_pWritingAppAsUTF8 == NULL);
4320 assert(m_pTitleAsUTF8 == NULL);
4371 assert(pos <= stop);
4374 assert(pos == stop);
4385 assert(m_timecodeScale >= 1);
4463 assert(count >= 0);
4473 assert(count >= 0);
4481 assert(count >= 0);
4491 assert(count >= 0);
4499 assert(pReader);
4500 assert(aes);
4519 assert(pos <= stop);
4527 assert(pReader);
4549 assert(pos <= stop);
4620 assert(pos <= stop);
4623 assert(pos == stop);
4630 assert(pReader);
4631 assert(compression);
4674 assert(pos <= stop);
4687 assert(pReader);
4688 assert(encryption);
4791 assert(pos <= stop);
5022 assert(pBlock);
5060 assert(pCurrEntry);
5061 assert(!pCurrEntry->EOS()); //?
5064 assert(pCurrBlock && pCurrBlock->GetTrackNumber() == m_info.number);
5069 assert(pCluster);
5070 assert(!pCluster->EOS());
5080 assert(pNextBlock);
5153 assert(pBlockEntry);
5155 assert(pBlock);
5156 assert(pBlock->GetTrackNumber() == m_info.number);
5175 assert(pResult);
5181 assert(pCluster);
5182 assert(pCluster->GetIndex() >= 0);
5188 assert(clusters);
5191 assert(count > 0);
5194 assert(i);
5195 assert(*i == pCluster);
5196 assert(pCluster->GetTime() <= time_ns);
5210 assert(mid < hi);
5213 assert(pCluster);
5214 assert(pCluster->GetIndex() >= 0);
5215 assert(pCluster->GetIndex() == long(mid - m_pSegment->m_clusters));
5224 assert(lo <= hi);
5227 assert(lo == hi);
5228 assert(lo > i);
5229 assert(lo <= j);
5233 assert(pCluster);
5234 assert(pCluster->GetTime() <= time_ns);
5252 assert(count >= 0);
5263 assert(count >= 0);
5270 assert(pReader);
5288 assert(pos <= stop);
5324 assert(pos <= stop);
5327 assert(pos == stop);
5358 assert(s.start >= 0);
5359 assert(s.size >= 0);
5362 assert(pos >= 0);
5395 assert(pos <= stop);
5398 assert(pos == stop);
5431 assert(pResult);
5437 assert(pCluster);
5438 assert(pCluster->GetIndex() >= 0);
5444 assert(clusters);
5447 assert(count > 0);
5450 assert(i);
5451 assert(*i == pCluster);
5452 assert(pCluster->GetTime() <= time_ns);
5466 assert(mid < hi);
5469 assert(pCluster);
5470 assert(pCluster->GetIndex() >= 0);
5471 assert(pCluster->GetIndex() == long(mid - m_pSegment->m_clusters));
5480 assert(lo <= hi);
5483 assert(lo == hi);
5484 assert(lo > i);
5485 assert(lo <= j);
5488 assert(pCluster);
5489 assert(pCluster->GetTime() <= time_ns);
5498 assert(pCluster);
5499 assert(pCluster->GetTime() <= time_ns);
5545 assert(s.start >= 0);
5546 assert(s.size >= 0);
5549 assert(pos >= 0);
5586 assert(pos <= stop);
5589 assert(pos == stop);
5629 assert(m_trackEntries == NULL);
5630 assert(m_trackEntriesEnd == NULL);
5653 assert(pos <= stop);
5656 assert(pos == stop);
5685 assert(payload_stop <= stop); // checked in ParseElement
5704 assert(pos <= stop);
5707 assert(pos == stop);
5714 assert(result >= 0);
5875 assert(pos <= track_stop);
5878 assert(pos == track_stop);
5909 assert(pResult);
5931 assert(pResult);
5959 assert(pResult);
6012 assert(m_pos >= m_element_start);
6013 //assert(m_element_size > m_size);
6016 assert(m_pos <= element_stop);
6019 assert(result >= 0);
6026 assert(m_pSegment);
6027 assert(m_pos >= m_element_start);
6032 assert(m_pos == m_element_start);
6033 assert(m_element_size < 0);
6044 assert((total < 0) || (avail <= total));
6045 assert((total < 0) || (m_pos <= total)); // TODO: verify this
6246 assert((cluster_stop < 0) || (pos <= cluster_stop));
6249 assert((cluster_stop < 0) || (pos <= cluster_stop));
6272 assert(m_pos >= m_element_start);
6273 assert(m_timecode >= 0);
6274 // assert(m_size > 0);
6275 // assert(m_element_size > m_size);
6292 assert((total < 0) || (avail <= total));
6419 assert((cluster_stop < 0) || (pos <= cluster_stop));
6422 assert(m_element_size > 0);
6425 assert((cluster_stop < 0) || (m_pos <= cluster_stop));
6431 assert(pLast);
6434 assert(pBlock);
6444 assert((cluster_stop < 0) || (stop <= cluster_stop));
6467 assert((total < 0) || (avail <= total));
6518 assert(pTracks);
6558 assert(pos <= avail);
6596 assert((total < 0) || (avail <= total));
6756 assert(pTracks);
6796 assert(pos <= avail);
6809 assert(pos <= payload_stop);
6812 assert(pos == payload_stop);
6825 assert(m_pos >= m_element_start);
6835 assert(m_entries);
6836 assert(m_entries_size > 0);
6837 assert(m_entries_count <= m_entries_size);
6841 assert(pEntry);
6860 assert(pSegment);
6861 assert(off >= 0);
6867 assert(pCluster);
6906 assert(p);
6920 assert(pos >= 0);
6931 assert(pSegment);
6932 assert(off >= 0); //relative to start of segment payload
6944 assert(id >= 0);
6945 assert(id == 0x0F43B675); //Cluster ID
6950 assert(size > 0);
6964 assert(id >= 0); //TODO
6965 assert((pos + len) <= stop);
6970 assert(size >= 0); //TODO
6971 assert((pos + len) <= stop);
6982 assert(pos <= stop);
6993 assert(pSegment);
6994 assert(off >= 0); // relative to segment
7005 assert((total < 0) || (avail <= total));
7090 assert(cluster_stop >= 0);
7195 assert((cluster_stop < 0) || (pos <= cluster_stop));
7218 assert(pInfo);
7221 assert(scale >= 1);
7240 assert(pBlock);
7257 assert(pBlock);
7265 assert((id == 0x20) || (id == 0x23)); // BlockGroup or SimpleBlock
7268 assert(m_entries == NULL);
7269 assert(m_entries_size == 0);
7276 assert(m_entries);
7277 assert(m_entries_size > 0);
7278 assert(m_entries_count <= m_entries_size);
7284 assert(entries);
7309 assert(m_entries);
7310 assert(m_entries_size > 0);
7311 assert(m_entries_count >= 0);
7312 assert(m_entries_count < m_entries_size);
7335 assert(id >= 0); // TODO
7336 assert((pos + len) <= stop);
7341 assert(size >= 0); // TODO
7342 assert((pos + len) <= stop);
7352 assert(size <= 8);
7355 assert(duration >= 0); // TODO
7357 assert(size <= 8);
7363 assert(status == 0);
7374 assert(pos <= stop);
7377 assert(pos == stop);
7378 assert(bpos >= 0);
7379 assert(bsize >= 0);
7408 assert(m_entries);
7409 assert(m_entries_size > 0);
7410 assert(m_entries_count >= 0);
7411 assert(m_entries_count < m_entries_size);
7456 assert(m_entries);
7459 assert(pFirst);
7485 assert(m_entries);
7490 assert(pLast);
7496 assert(pCurr);
7497 assert(m_entries);
7498 assert(m_entries_count > 0);
7501 assert(idx < size_t(m_entries_count));
7502 assert(m_entries[idx] == pCurr);
7522 assert(m_entries);
7523 assert(m_entries_count > 0);
7524 assert(idx < size_t(m_entries_count));
7528 assert(pNext);
7537 assert(pTrack);
7552 assert(i);
7559 assert(pEntry);
7560 assert(!pEntry->EOS());
7563 assert(pBlock);
7603 assert(status >= 0);
7611 assert(m_entries);
7612 assert(index < m_entries_count);
7616 assert(pEntry);
7617 assert(!pEntry->EOS());
7620 assert(pBlock);
7652 assert(m_pSegment);
7674 assert(pEntry);
7675 assert(!pEntry->EOS());
7678 assert(pBlock);
7698 assert(pEntry);
7699 assert(!pEntry->EOS());
7702 assert(pBlock);
7708 assert(tc_ >= 0);
7717 assert(pTracks);
7763 assert(pEntry);
7764 assert(!pEntry->EOS());
7767 assert(pBlock);
7790 assert(m_entries);
7791 assert(index < m_entries_count);
7795 assert(pEntry);
7796 assert(!pEntry->EOS());
7799 assert(pBlock);
7817 assert(pTracks);
7845 assert(pTrack);
7861 assert(pEntry);
7862 assert(!pEntry->EOS());
7865 assert(pBlock);
7924 assert(pBlock); //TODO
7929 assert(m_pBlock == NULL);
7963 assert(m_start >= 0);
7964 assert(m_size >= 0);
7965 assert(m_track <= 0);
7966 assert(m_frames == NULL);
7967 assert(m_frame_count <= 0);
8050 assert(pos <= stop);
8055 assert(m_frames);
8087 assert(pf < pf_end);
8097 assert(pf < pf_end);
8098 assert(pos <= stop);
8124 assert((pos + f.len) <= stop);
8130 assert(pos == stop);
8146 assert((pos + frame_size) <= stop);
8156 assert(pos == stop);
8158 assert(lacing == 3); // EBML lacing
8200 assert(pf < pf_end);
8203 assert(prev.len == frame_size);
8207 assert(pf < pf_end);
8222 assert(pos <= stop);
8243 assert(pos <= stop);
8244 assert(pf < pf_end);
8247 assert(prev.len == frame_size);
8251 assert(pf < pf_end);
8254 assert(pf == pf_end);
8274 assert((pos + f.len) <= stop);
8280 assert(pos == stop);
8291 assert(tc0 >= 0);
8299 assert(pCluster);
8305 assert(pInfo);
8308 assert(scale >= 1);
8338 assert(idx >= 0);
8339 assert(idx < m_frame_count);
8342 assert(f.pos > 0);
8343 assert(f.len > 0);
8349 assert(pReader);
8350 assert(buf);