Lines Matching defs:assert
29 assert(pReader);
30 assert(pos >= 0);
37 // assert(status >= 0);
38 // assert((total < 0) || (available <= total));
39 // assert(pos < available);
40 // assert((available - pos) >= 1); //assume here max u-int len is 8
67 // assert((available - pos) >= len);
103 assert(pReader);
104 assert(pos >= 0);
109 assert(status >= 0);
110 assert((total < 0) || (available <= total));
124 assert(status == 0);
146 assert(pReader);
147 assert(pos >= 0);
179 assert(pReader);
180 assert(pos >= 0);
218 assert(size == 8);
251 assert(pReader);
252 assert(pos >= 0);
253 assert(size > 0);
254 assert(size <= 8);
369 assert(pReader);
370 assert(pos >= 0);
375 assert(status >= 0);
376 assert((total < 0) || (available <= total));
381 assert(id >= 0);
382 assert(len > 0);
383 assert(len <= 8);
384 assert((pos + len) <= available);
392 assert(size >= 0);
393 assert(size <= 8);
394 assert(len > 0);
395 assert(len <= 8);
396 assert((pos + len) <= available);
401 assert(val >= 0);
415 assert(pReader);
416 assert(pos >= 0);
421 assert(status >= 0);
422 assert((total < 0) || (available <= total));
426 assert(id >= 0);
427 assert(len > 0);
428 assert(len <= 8);
429 assert((pos + len) <= available);
437 assert(size_ >= 0);
438 assert(len > 0);
439 assert(len <= 8);
440 assert((pos + len) <= available);
443 assert((pos + size_) <= available);
448 assert(buf); //TODO
451 assert(status == 0); //TODO
495 assert(pReader);
570 assert(len > 0);
571 assert(len <= 8);
673 assert(pos == end);
713 assert(p);
732 assert(pReader);
733 assert(pos >= 0);
869 assert((total < 0) || (available <= total));
872 assert((segment_stop < 0) || (total < 0) || (segment_stop <= total));
873 assert((segment_stop < 0) || (m_pos <= segment_stop));
1030 assert((segment_stop < 0) || (m_pos <= segment_stop));
1070 assert((total < 0) || (avail <= total));
1189 assert(m_pCues); //TODO
1215 assert(cluster_off >= 0); //have cluster
1263 assert(idx < m_clusterSize);
1266 assert(pCluster);
1267 assert(pCluster->m_index < 0);
1270 assert(off >= 0);
1294 assert((segment_stop < 0) || (m_pos <= segment_stop));
1329 assert(pCluster);
1332 assert(m_clusters);
1333 assert(idx < m_clusterSize);
1334 assert(m_clusters[idx] == pCluster);
1341 assert((segment_stop < 0) || (m_pos <= segment_stop));
1417 assert(false);
1466 assert((segment_stop < 0) || (pos <= segment_stop));
1470 assert(cluster_size >= 0);
1477 assert(idx < m_clusterSize);
1480 assert(pCluster);
1481 assert(pCluster->m_index < 0);
1484 assert(off >= 0);
1491 assert((segment_stop < 0) || (m_pos <= segment_stop));
1504 assert(m_pos < 0);
1505 assert(m_pUnknownSize);
1508 assert(m_pUnknownSize->GetElementSize() < 0); //TODO: verify this
1513 assert(pos > element_start);
1526 assert((total < 0) || (avail <= total));
1537 assert(element_size > 0);
1545 assert(element_size > 0);
1585 assert(element_size > 0);
1600 assert(false);
1650 assert((segment_stop < 0) || (pos <= segment_stop));
1653 assert(element_size >= 0);
1668 assert(status > 0); //nothing left to parse of this cluster
1673 assert(size >= 0);
1687 assert(pCluster);
1688 assert(pCluster->m_index >= 0);
1693 assert(size >= count);
1696 assert(idx == m_clusterCount);
1719 assert(m_clusters);
1722 assert(*p);
1723 assert((*p)->m_index < 0);
1726 assert(q < (m_clusters + size));
1731 assert((*qq)->m_index < 0);
1748 assert(pCluster);
1749 assert(pCluster->m_index < 0);
1750 assert(idx >= m_clusterCount);
1755 assert(size >= count);
1776 assert(m_clusters);
1781 assert(q >= p);
1782 assert(q < (m_clusters + size));
1787 assert((*qq)->m_index < 0);
1800 assert(m_clusters == NULL);
1801 assert(m_clusterSize == 0);
1802 assert(m_clusterCount == 0);
1803 //assert(m_size >= 0);
1817 assert(m_pInfo);
1818 assert(m_pTracks);
1891 assert(pos <= stop);
1894 assert(pos == stop);
1948 assert(pos <= stop);
1951 assert(pos == stop);
1954 assert(count_ >= 0);
1955 assert(count_ <= entry_count);
1960 assert(count_ >= 0);
1961 assert(count_ <= void_element_count);
2018 assert(result == 0);
2019 assert((pos + len) <= stop);
2024 assert(id == 0x0C53BB6B); //Cues ID
2027 assert(pos < stop);
2032 assert(result == 0);
2033 assert((pos + len) <= stop);
2036 assert(size >= 0);
2039 assert((pos + size) <= stop);
2046 assert(m_pCues); //TODO
2069 assert((total < 0) || (avail <= total));
2110 assert((segment_stop < 0) || (pos <= segment_stop));
2146 assert((segment_stop < 0) || (pos <= segment_stop));
2171 assert(m_pCues); //TODO
2191 assert(seekIdId == 0x13AB); //SeekID ID
2192 assert((pos + len) <= stop);
2197 assert(seekIdSize >= 0);
2198 assert((pos + len) <= stop);
2203 assert(seekId >= 0);
2204 assert(len == seekIdSize);
2205 assert((pos + len) <= stop);
2211 assert(seekPosId == 0x13AC); //SeekPos ID
2212 assert((pos + len) <= stop);
2217 assert(seekPosSize >= 0);
2218 assert((pos + len) <= stop);
2221 assert((pos + seekPosSize) <= stop);
2224 assert(seekOff >= 0);
2225 assert(seekOff < m_size);
2228 assert(pos == stop);
2231 assert(seekPos < (m_start + m_size));
2365 assert(pCP);
2395 assert(m_count == 0);
2396 assert(m_preload_count == 0);
2412 assert(id >= 0); //TODO
2413 assert((pos + len) <= stop);
2418 assert(size >= 0);
2419 assert((pos + len) <= stop);
2422 assert((pos + size) <= stop);
2428 assert(pos <= stop);
2437 assert(m_count == 0);
2484 assert(id >= 0); //TODO
2485 assert((m_pos + len) <= stop);
2490 assert(size >= 0);
2491 assert((m_pos + len) <= stop);
2494 assert((m_pos + size) <= stop);
2499 assert(m_pos <= stop);
2504 assert(m_preload_count > 0);
2507 assert(pCP);
2508 assert((pCP->GetTimeCode() >= 0) || (-pCP->GetTimeCode() == idpos));
2515 assert(m_pos <= stop);
2531 assert(time_ns >= 0);
2532 assert(pTrack);
2537 assert(m_cue_points);
2538 assert(m_count > 0);
2547 assert(pCP);
2565 assert(k < jj);
2568 assert(pCP);
2579 assert(i <= j);
2582 assert(i == j);
2583 assert(i <= jj);
2584 assert(i > ii);
2587 assert(pCP);
2588 assert(pCP->GetTime(m_pSegment) <= time_ns);
2603 assert(pCP);
2619 assert(k < jj);
2622 assert(pCP);
2631 assert(i <= j);
2634 assert(i == j);
2635 assert(i <= jj);
2636 assert(i > ii);
2639 assert(pCP);
2640 assert(pCP->GetTime(m_pSegment) <= time_ns);
2669 assert(m_cue_points);
2685 assert(k < jj);
2688 assert(pCP);
2697 assert(i <= j);
2700 assert(i == j);
2701 assert(i <= jj);
2707 assert(pCP);
2708 assert(pCP->GetTime(m_pSegment) > time_ns);
2734 assert(pp);
2737 assert(pCP);
2738 assert(pCP->GetTimeCode() >= 0);
2763 assert(pp);
2766 assert(pCP);
2769 assert(pCP->GetTimeCode() >= 0);
2774 assert(pp);
2777 assert(pCP);
2778 assert(pCP->GetTimeCode() >= 0);
2790 assert(pCurr->GetTimeCode() >= 0);
2791 assert(m_cue_points);
2792 assert(m_count >= 1);
2798 assert(index < count);
2801 assert(pp);
2802 assert(pp[index] == pCurr);
2810 assert(pNext);
2815 assert(index < m_count);
2818 assert(pp);
2819 assert(pp[index] == pCurr);
2827 assert(pNext);
2828 assert(pNext->GetTimeCode() >= 0);
2869 assert(k < jj);
2872 assert(pCluster);
2875 //assert(pos_);
2879 assert(pos >= 0);
2889 assert(i == j);
2890 //assert(Cluster::HasBlockEntries(this, tp.m_pos));
2893 assert(pCluster);
2898 assert(m_clusters);
2899 assert(m_clusterPreloadCount > 0);
2900 assert(m_clusters[idx] == pCluster);
2927 assert(k < jj);
2930 assert(pCluster);
2933 //assert(pos_);
2937 assert(pos >= 0);
2947 assert(i == j);
2948 //assert(Cluster::HasBlockEntries(this, tp.m_pos));
2955 assert(pCluster);
2960 assert(m_clusters);
2961 assert(m_clusterPreloadCount > 0);
2962 assert(m_clusters[idx] == pCluster);
2976 assert(pos > 0);
2994 assert(m_track_positions == NULL);
2995 assert(m_track_positions_count == 0);
3006 assert(id == 0x3B); //CuePoint ID
3007 //assert((pos + len) <= stop);
3012 assert(size >= 0);
3013 //assert((pos + len) <= stop);
3016 //assert((pos + size) <= stop);
3034 assert(id >= 0); //TODO
3035 assert((pos + len) <= stop);
3040 assert(size >= 0);
3041 assert((pos + len) <= stop);
3044 assert((pos + size) <= stop);
3053 assert(pos <= stop);
3056 assert(m_timecode >= 0);
3057 assert(m_track_positions_count > 0);
3075 assert(id >= 0); //TODO
3076 assert((pos + len) <= stop);
3081 assert(size >= 0);
3082 assert((pos + len) <= stop);
3085 assert((pos + size) <= stop);
3094 assert(pos <= stop);
3097 assert(size_t(p - m_track_positions) == m_track_positions_count);
3122 assert(id >= 0); //TODO
3123 assert((pos + len) <= stop);
3128 assert(size >= 0);
3129 assert((pos + len) <= stop);
3132 assert((pos + size) <= stop);
3144 assert(pos <= stop);
3147 assert(m_pos >= 0);
3148 assert(m_track > 0);
3149 //assert(m_block > 0);
3155 assert(pTrack);
3181 assert(pSegment);
3182 assert(m_timecode >= 0);
3185 assert(pInfo);
3188 assert(scale >= 1);
3205 assert(result >= 0);
3240 assert(pCluster);
3254 assert(pCluster);
3268 assert(pCurr);
3269 assert(pCurr != &m_eos);
3270 assert(m_clusters);
3276 assert(m_clusterCount > 0);
3277 assert(idx < m_clusterCount);
3278 assert(pCurr == m_clusters[idx]);
3286 assert(pNext);
3287 assert(pNext->m_index >= 0);
3288 assert(pNext->m_index == idx);
3293 assert(m_clusterPreloadCount > 0);
3301 assert(m_size >= 0); //TODO
3308 assert(result == 0); //TODO
3309 assert((pos + len) <= stop); //TODO
3312 assert(id == 0x0F43B675); //Cluster ID //TODO
3318 assert(result == 0); //TODO
3319 assert((pos + len) <= stop); //TODO
3322 assert(size > 0); //TODO
3323 //assert((pCurr->m_size <= 0) || (pCurr->m_size == size));
3326 assert((pos + size) <= stop); //TODO
3342 assert(result == 0); //TODO
3343 assert((pos + len) <= stop); //TODO
3348 assert(id > 0); //TODO
3354 assert(result == 0); //TODO
3355 assert((pos + len) <= stop); //TODO
3358 assert(size >= 0); //TODO
3361 assert((pos + size) <= stop); //TODO
3383 assert(status >= 0);
3414 assert(k < jj);
3417 assert(pNext);
3418 assert(pNext->m_index < 0);
3421 //assert(pos_);
3434 assert(i == j);
3440 assert(pNext);
3445 assert(m_clusters);
3446 assert(idx_next < m_clusterSize);
3447 assert(m_clusters[idx_next] == pNext);
3459 assert(pCurr);
3460 assert(!pCurr->EOS());
3461 assert(m_clusters);
3467 assert(m_clusters[pCurr->m_index] == pCurr);
3494 assert(m_pos > 0);
3503 assert((total < 0) || (avail <= total));
3576 //assert((pCurr->m_size <= 0) || (pCurr->m_size == size));
3584 assert((segment_stop < 0) || (pos <= segment_stop));
3618 assert((total < 0) || (avail <= total));
3733 assert(m_pCues); //TODO
3737 assert((segment_stop < 0) || (pos <= segment_stop));
3748 assert((segment_stop < 0) || (pos <= segment_stop));
3770 assert(off_next > 0); //have cluster
3792 assert(k < jj);
3795 assert(pNext);
3796 assert(pNext->m_index < 0);
3799 assert(pos >= 0);
3812 assert(i == j);
3833 assert(pNext);
3838 assert(m_clusters);
3839 assert(idx_next < m_clusterSize);
3840 assert(m_clusters[idx_next] == pNext);
3943 assert((segment_stop < 0) || (pos <= segment_stop));
3947 assert(cluster_size >= 0); //TODO: handle cluster_size = 0
3953 assert((segment_stop < 0) || (pos <= segment_stop));
3966 assert(pCluster);
3967 assert(pCluster->m_index == 0);
3986 assert(k < m_clusterCount);
3989 assert(pCluster);
3990 assert(pCluster->m_index == k);
3999 assert(i <= j);
4002 assert(i == j);
4003 assert(i > 0);
4004 assert(i <= m_clusterCount);
4009 assert(pCluster);
4010 assert(pCluster->m_index == k);
4011 assert(pCluster->GetTime() <= time_ns);
4022 assert(pTrack);
4028 assert(i);
4032 assert(pCluster);
4033 assert(pCluster->m_index == 0); //m_clusterCount > 0
4034 assert(pCluster->m_pSegment == this);
4060 assert(mid < hi);
4063 assert(pCluster);
4064 assert(pCluster->m_index == long(mid - m_clusters));
4065 assert(pCluster->m_pSegment == this);
4074 assert(lo <= hi);
4077 assert(lo == hi);
4078 assert(lo > i);
4079 assert(lo <= j);
4084 assert(pCluster);
4085 assert(pCluster->GetTime() <= time_ns);
4098 assert(pTrack->GetType() == 1); //video
4111 assert(mid < hi);
4114 assert(pCluster);
4123 assert(lo <= hi);
4126 assert(lo == hi);
4127 assert(lo > i);
4128 assert(lo <= j);
4131 assert(pCluster);
4132 assert(pCluster->GetTime() <= time_ns);
4146 assert(pCluster);
4147 assert(pCluster->GetTime() <= time_ns);
4181 assert(pCP);
4182 assert(pTP);
4183 assert(pTP->m_track == pTrack->GetNumber());
4220 assert(m_pInfo);
4257 assert(m_pMuxingAppAsUTF8 == NULL);
4258 assert(m_pWritingAppAsUTF8 == NULL);
4259 assert(m_pTitleAsUTF8 == NULL);
4339 assert(pos <= stop);
4342 assert(pos == stop);
4359 assert(m_timecodeScale >= 1);
4448 assert(count >= 0);
4458 assert(count >= 0);
4466 assert(count >= 0);
4476 assert(count >= 0);
4486 assert(pReader);
4487 assert(encryption);
4496 assert(id >= 0); //TODO: handle error case
4497 assert((pos + len) <= stop);
4528 assert(id >= 0); //TODO: handle error case
4529 assert((pos + len) <= stop);
4534 assert(size >= 0); //TODO: handle error case
4535 assert((pos + len) <= stop);
4538 assert((pos + size) <= stop);
4541 assert(pos <= stop);
4549 assert(pReader);
4562 assert(id >= 0);
4563 assert((pos1 + len) <= stop);
4568 assert(size >= 0);
4569 assert((pos1 + len) <= stop);
4581 assert(pos1 <= stop);
4601 assert(id >= 0); //TODO: handle error case
4602 assert((pos + len) <= stop);
4612 assert(encoding_scope_ > 0);
4619 assert(id >= 0); //TODO: handle error case
4620 assert((pos + len) <= stop);
4625 assert(size >= 0); //TODO: handle error case
4626 assert((pos + len) <= stop);
4629 assert((pos + size) <= stop);
4646 assert(pos <= stop);
4650 assert(pos == stop);
4885 assert(pBlock);
4926 assert(pCurrEntry);
4927 assert(!pCurrEntry->EOS()); //?
4930 assert(pCurrBlock->GetTrackNumber() == m_info.number);
4933 assert(pCluster);
4934 assert(!pCluster->EOS());
4946 assert(pNextBlock);
5025 assert(count >= 0);
5036 assert(count >= 0);
5043 assert(pReader);
5055 assert(id >= 0);
5056 assert((pos1 + len) <= stop);
5061 assert(size >= 0);
5062 assert((pos1 + len) <= stop);
5071 assert(pos1 <= stop);
5083 assert(id >= 0);
5084 assert((pos + len) <= stop);
5089 assert(size1 >= 0);
5090 assert((pos + len) <= stop);
5107 assert(pos <= stop);
5110 assert(pos == stop);
5161 assert(s.start >= 0);
5162 assert(s.size >= 0);
5165 assert(pos >= 0);
5213 assert(pos <= stop);
5216 assert(pos == stop);
5238 assert(pBlockEntry);
5241 assert(pBlock);
5242 assert(pBlock->GetTrackNumber() == m_info.number);
5257 assert(pResult);
5263 assert(pCluster);
5264 assert(pCluster->GetIndex() >= 0);
5270 assert(clusters);
5273 assert(count > 0);
5276 assert(i);
5277 assert(*i == pCluster);
5278 assert(pCluster->GetTime() <= time_ns);
5293 assert(mid < hi);
5296 assert(pCluster);
5297 assert(pCluster->GetIndex() >= 0);
5298 assert(pCluster->GetIndex() == long(mid - m_pSegment->m_clusters));
5307 assert(lo <= hi);
5310 assert(lo == hi);
5311 assert(lo > i);
5312 assert(lo <= j);
5315 assert(pCluster);
5316 assert(pCluster->GetTime() <= time_ns);
5326 assert(pCluster);
5327 assert(pCluster->GetTime() <= time_ns);
5395 assert(s.start >= 0);
5396 assert(s.size >= 0);
5399 assert(pos >= 0);
5447 assert(pos <= stop);
5450 assert(pos == stop);
5472 assert(pBlockEntry);
5475 assert(pBlock);
5476 assert(pBlock->GetTrackNumber() == m_info.number);
5491 assert(pResult);
5497 assert(pCluster);
5498 assert(pCluster->GetIndex() >= 0);
5504 assert(clusters);
5507 assert(count > 0);
5510 assert(i);
5511 assert(*i == pCluster);
5512 assert(pCluster->GetTime() <= time_ns);
5527 assert(mid < hi);
5530 assert(pCluster);
5531 assert(pCluster->GetIndex() >= 0);
5532 assert(pCluster->GetIndex() == long(mid - m_pSegment->m_clusters));
5541 assert(lo <= hi);
5544 assert(lo == hi);
5545 assert(lo > i);
5546 assert(lo <= j);
5551 assert(pCluster);
5552 assert(pCluster->GetTime() <= time_ns);
5602 assert(m_trackEntries == NULL);
5603 assert(m_trackEntriesEnd == NULL);
5632 assert(pos <= stop);
5635 assert(pos == stop);
5669 assert(payload_stop <= stop); //checked in ParseElement
5693 assert(pos <= stop);
5696 assert(pos == stop);
5705 assert(result >= 0);
5899 assert(pos <= track_stop);
5902 assert(pos == track_stop);
5943 assert(i.type == Track::kAudio);
5962 assert(pTrack);
6024 assert(m_pos >= m_element_start);
6025 //assert(m_element_size > m_size);
6028 assert(m_pos <= element_stop);
6031 assert(result >= 0);
6040 assert(m_pSegment);
6041 assert(m_pos >= m_element_start);
6046 assert(m_pos == m_element_start);
6047 assert(m_element_size < 0);
6058 assert((total < 0) || (avail <= total));
6059 assert((total < 0) || (m_pos <= total)); //TODO: verify this
6270 assert((cluster_stop < 0) || (pos <= cluster_stop));
6273 assert((cluster_stop < 0) || (pos <= cluster_stop));
6298 assert(m_pos >= m_element_start);
6299 assert(m_timecode >= 0);
6300 //assert(m_size > 0);
6301 //assert(m_element_size > m_size);
6318 assert((total < 0) || (avail <= total));
6450 assert((cluster_stop < 0) || (pos <= cluster_stop));
6453 assert(m_element_size > 0);
6456 assert((cluster_stop < 0) || (m_pos <= cluster_stop));
6463 assert(pLast);
6466 assert(pBlock);
6476 assert((cluster_stop < 0) || (stop <= cluster_stop));
6503 assert((total < 0) || (avail <= total));
6555 assert(pTracks);
6598 assert(pos <= avail);
6639 assert((total < 0) || (avail <= total));
6791 assert(pTracks);
6834 assert(pos <= avail);
6848 assert(pos <= payload_stop);
6851 assert(pos == payload_stop);
6866 assert(m_pos >= m_element_start);
6876 assert(m_entries);
6877 assert(m_entries_size > 0);
6878 assert(m_entries_count <= m_entries_size);
6883 assert(pEntry);
6906 assert(pSegment);
6907 assert(off >= 0);
6915 assert(pCluster);
6964 assert(p);
6988 assert(pos >= 0);
7005 assert(pSegment);
7006 assert(off >= 0); //relative to segment
7018 assert(id >= 0);
7019 assert(id == 0x0F43B675); //Cluster ID
7024 assert(size > 0);
7038 assert(id >= 0); //TODO
7039 assert((pos + len) <= stop);
7044 assert(size >= 0); //TODO
7045 assert((pos + len) <= stop);
7056 assert(pos <= stop);
7070 assert(pSegment);
7071 assert(off >= 0); //relative to segment
7082 assert((total < 0) || (avail <= total));
7170 assert(cluster_stop >= 0);
7278 assert((cluster_stop < 0) || (pos <= cluster_stop));
7305 assert(pInfo);
7308 assert(scale >= 1);
7329 assert(pBlock);
7348 assert(pBlock);
7359 assert((id == 0x20) || (id == 0x23)); //BlockGroup or SimpleBlock
7363 assert(m_entries == NULL);
7364 assert(m_entries_size == 0);
7373 assert(m_entries);
7374 assert(m_entries_size > 0);
7375 assert(m_entries_count <= m_entries_size);
7382 assert(entries);
7410 assert(m_entries);
7411 assert(m_entries_size > 0);
7412 assert(m_entries_count >= 0);
7413 assert(m_entries_count < m_entries_size);
7437 assert(id >= 0); //TODO
7438 assert((pos + len) <= stop);
7443 assert(size >= 0); //TODO
7444 assert((pos + len) <= stop);
7458 assert(size <= 8);
7461 assert(duration >= 0); //TODO
7465 assert(size <= 8);
7471 assert(status == 0); //TODO
7480 assert(pos <= stop);
7483 assert(pos == stop);
7484 assert(bpos >= 0);
7485 assert(bsize >= 0);
7526 assert(m_entries);
7527 assert(m_entries_size > 0);
7528 assert(m_entries_count >= 0);
7529 assert(m_entries_count < m_entries_size);
7580 assert(m_entries);
7583 assert(pFirst);
7613 assert(m_entries);
7618 assert(pLast);
7628 assert(pCurr);
7629 assert(m_entries);
7630 assert(m_entries_count > 0);
7633 assert(idx < size_t(m_entries_count));
7634 assert(m_entries[idx] == pCurr);
7657 assert(m_entries);
7658 assert(m_entries_count > 0);
7659 assert(idx < size_t(m_entries_count));
7663 assert(pNext);
7679 assert(pTrack);
7694 assert(i);
7701 assert(pEntry);
7702 assert(!pEntry->EOS());
7705 assert(pBlock);
7747 assert(status >= 0);
7755 assert(m_entries);
7756 assert(index < m_entries_count);
7760 assert(pEntry);
7761 assert(!pEntry->EOS());
7764 assert(pBlock);
7804 assert(m_pSegment);
7826 assert(pEntry);
7827 assert(!pEntry->EOS());
7830 assert(pBlock);
7850 assert(pEntry);
7851 assert(!pEntry->EOS());
7854 assert(pBlock);
7860 assert(tc_ >= 0);
7869 assert(pTracks);
7917 assert(pEntry);
7918 assert(!pEntry->EOS());
7921 assert(pBlock);
7947 assert(m_entries);
7948 assert(index < m_entries_count);
7952 assert(pEntry);
7953 assert(!pEntry->EOS());
7956 assert(pBlock);
7965 assert(tc_ >= 0);
7977 assert(pTracks);
8007 assert(pTrack);
8023 assert(pEntry);
8024 assert(!pEntry->EOS());
8027 assert(pBlock);
8136 assert(pBlock); //TODO
8141 assert(m_pBlock == NULL);
8191 assert(pReader);
8192 assert(m_start >= 0);
8193 assert(m_size >= 0);
8194 assert(m_track <= 0);
8195 assert(m_frames == NULL);
8196 assert(m_frame_count <= 0);
8278 assert(pos <= stop);
8283 assert(m_frames);
8318 assert(pf < pf_end);
8328 assert(pf < pf_end);
8329 assert(pos <= stop);
8356 assert((pos + f.len) <= stop);
8362 assert(pos == stop);
8381 assert((pos + frame_size) <= stop);
8391 assert(pos == stop);
8395 assert(lacing == 3); //EBML lacing
8438 assert(pf < pf_end);
8441 assert(prev.len == frame_size);
8443 assert(pf < pf_end);
8458 assert(pos <= stop);
8479 assert(pos <= stop);
8480 assert(pf < pf_end);
8483 assert(prev.len == frame_size);
8485 assert(pf < pf_end);
8488 assert(pf == pf_end);
8509 assert((pos + f.len) <= stop);
8515 assert(pos == stop);
8528 assert(tc0 >= 0);
8531 assert(tc >= 0);
8539 assert(pCluster);
8545 assert(pInfo);
8548 assert(scale >= 1);
8598 assert(idx >= 0);
8599 assert(idx < m_frame_count);
8602 assert(f.pos > 0);
8603 assert(f.len > 0);
8611 assert(pReader);
8612 assert(buf);