home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / test / source / TestAVIReadIndex.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-14  |  9.3 KB  |  314 lines
  1. #pragma include_alias("stdafx.h", "test.h")
  2. #pragma include_alias("AVIReadIndex.h", "..\VirtualDub\h\AVIReadIndex.h")
  3. #include "..\VirtualDub\source\AVIReadIndex.cpp"
  4.  
  5. namespace {
  6.     struct Chunk {
  7.         sint64 pos;
  8.         uint32 len;
  9.     };
  10.  
  11.     void AddChunks(VDAVIReadIndex& idx, const Chunk *chunks, size_t n) {
  12.         while(n--) {
  13.             idx.AddChunk(chunks->pos, chunks->len);
  14.             ++chunks;
  15.         }
  16.     }
  17.  
  18.     template<size_t N>
  19.     void AddChunks(VDAVIReadIndex& idx, const Chunk (&chunks)[N]) {
  20.         AddChunks(idx, chunks, N);
  21.     }
  22. }
  23.  
  24. DEFINE_TEST(AVIReadIndex) {
  25.     VDAVIReadIndex ari;
  26.  
  27.     ////////////////////////////////////////////////////////////////////////
  28.     //
  29.     // VBR (video)
  30.     //
  31.     ////////////////////////////////////////////////////////////////////////
  32.  
  33.     static const Chunk kChunks1[]={
  34.         { 100, 100 },
  35.         { 200, 0x80000001 },
  36.         { 300, 0 },
  37.         { 400, 0x80000002 },
  38.         { 500, 5 }
  39.     };
  40.  
  41.     ari.Init(0);
  42.     AddChunks(ari, kChunks1);
  43.     ari.Finalize();
  44.  
  45.     TEST_ASSERT(ari.GetChunkCount() == 5);
  46.     TEST_ASSERT(ari.GetSampleCount() == 5);
  47.  
  48.     VDAVIReadIndexIterator it;
  49.     sint64 chunkPos;
  50.     uint32 offset;
  51.     uint32 byteSize;
  52.  
  53.     ari.FindSampleRange(it, 0, 1); ari.GetNextSampleRange(it, chunkPos, offset, byteSize);
  54.     TEST_ASSERT(chunkPos == 100);
  55.     TEST_ASSERT(offset == 0);
  56.     TEST_ASSERT(byteSize == 100);
  57.  
  58.     ari.FindSampleRange(it, 1, 1); ari.GetNextSampleRange(it, chunkPos, offset, byteSize);
  59.     TEST_ASSERT(chunkPos == 200);
  60.     TEST_ASSERT(offset == 0);
  61.     TEST_ASSERT(byteSize == 1);
  62.  
  63.     ari.FindSampleRange(it, 2, 1); ari.GetNextSampleRange(it, chunkPos, offset, byteSize);
  64.     TEST_ASSERT(chunkPos == 300);
  65.     TEST_ASSERT(offset == 0);
  66.     TEST_ASSERT(byteSize == 0);
  67.  
  68.     ari.FindSampleRange(it, 3, 1); ari.GetNextSampleRange(it, chunkPos, offset, byteSize);
  69.     TEST_ASSERT(chunkPos == 400);
  70.     TEST_ASSERT(offset == 0);
  71.     TEST_ASSERT(byteSize == 2);
  72.  
  73.     ari.FindSampleRange(it, 4, 1); ari.GetNextSampleRange(it, chunkPos, offset, byteSize);
  74.     TEST_ASSERT(chunkPos == 500);
  75.     TEST_ASSERT(offset == 0);
  76.     TEST_ASSERT(byteSize == 5);
  77.  
  78.     TEST_ASSERT(ari.NearestKey(-1) == -1);
  79.     TEST_ASSERT(ari.NearestKey(0) == -1);
  80.     TEST_ASSERT(ari.NearestKey(1) == 1);
  81.     TEST_ASSERT(ari.NearestKey(2) == 1);
  82.     TEST_ASSERT(ari.NearestKey(3) == 3);
  83.     TEST_ASSERT(ari.NearestKey(4) == 3);
  84.     TEST_ASSERT(ari.NearestKey(5) == 3);
  85.  
  86.     TEST_ASSERT(ari.IsKey(-1) == false);
  87.     TEST_ASSERT(ari.IsKey(0) == false);
  88.     TEST_ASSERT(ari.IsKey(1) == true);
  89.     TEST_ASSERT(ari.IsKey(2) == false);
  90.     TEST_ASSERT(ari.IsKey(3) == true);
  91.     TEST_ASSERT(ari.IsKey(4) == false);
  92.     TEST_ASSERT(ari.IsKey(5) == false);
  93.  
  94.     TEST_ASSERT(ari.PrevKey(-1) == -1);
  95.     TEST_ASSERT(ari.PrevKey(0) == -1);
  96.     TEST_ASSERT(ari.PrevKey(1) == -1);
  97.     TEST_ASSERT(ari.PrevKey(2) == 1);
  98.     TEST_ASSERT(ari.PrevKey(3) == 1);
  99.     TEST_ASSERT(ari.PrevKey(4) == 3);
  100.     TEST_ASSERT(ari.PrevKey(5) == 3);
  101.  
  102.     TEST_ASSERT(ari.NextKey(-1) == 1);
  103.     TEST_ASSERT(ari.NextKey(0) == 1);
  104.     TEST_ASSERT(ari.NextKey(1) == 3);
  105.     TEST_ASSERT(ari.NextKey(2) == 3);
  106.     TEST_ASSERT(ari.NextKey(3) == -1);
  107.     TEST_ASSERT(ari.NextKey(4) == -1);
  108.     TEST_ASSERT(ari.NextKey(5) == -1);
  109.  
  110.     static const Chunk kChunks2[]={
  111.         { 0x0000000000000000ULL, 1 },
  112.         { 0x00000000FFFFFFFFULL, 2 },
  113.         { 0x0000000100000000ULL, 3 },
  114.         { 0x00000001FFFFFFFFULL, 4 },
  115.         { 0x0000000200000000ULL, 5 },
  116.         { 0x00000002FFFFFFFFULL, 6 },
  117.         { 0x0000000300000000ULL, 7 },
  118.         { 0x00000003FFFFFFFFULL, 8 },
  119.         { 0x0000000400000000ULL, 9 },
  120.         { 0x00000004FFFFFFFFULL, 10 },
  121.     };
  122.  
  123.     ari.Init(0);
  124.     AddChunks(ari, kChunks2);
  125.     ari.Finalize();
  126.  
  127.     TEST_ASSERT(ari.GetChunkCount() == 10);
  128.     TEST_ASSERT(ari.GetSampleCount() == 10);
  129.  
  130.     for(int i=0; i<10; ++i) {
  131.         const Chunk& ch = kChunks2[i];
  132.         ari.FindSampleRange(it, i, 1); ari.GetNextSampleRange(it, chunkPos, offset, byteSize);
  133.         TEST_ASSERT(chunkPos == ch.pos);
  134.         TEST_ASSERT(offset == 0);
  135.         TEST_ASSERT(byteSize == ch.len);
  136.     }
  137.  
  138.     vdfastvector<uint32> sizes;
  139.     vdfastvector<sint64> positions;
  140.     vdfastvector<int> order;
  141.  
  142.     sint64 pos = 0;
  143.     ari.Clear();
  144.     for(int i=0; i<10000; ++i) {
  145.         uint32 cksize = rand() ^ (rand() << 12) ^ (rand() << 24);
  146.         uint32 ckskip = rand() ^ (rand() << 12) ^ (rand() << 24);
  147.         
  148.         positions.push_back(pos);
  149.         sizes.push_back(cksize);
  150.         order.push_back(i);
  151.  
  152.         ari.AddChunk(pos, cksize);
  153.         pos += cksize & 0x7FFFFFFF;
  154.         pos += ckskip;
  155.     }
  156.  
  157.     ari.Finalize();
  158.  
  159.     std::random_shuffle(order.begin(), order.end());
  160.  
  161.     for(int i=0; i<10000; ++i) {
  162.         int j = order[i];
  163.         ari.FindSampleRange(it, j, 1); ari.GetNextSampleRange(it, chunkPos, offset, byteSize);
  164.  
  165.         TEST_ASSERT(chunkPos == positions[j]);
  166.         TEST_ASSERT(offset == 0);
  167.         TEST_ASSERT(byteSize == (sizes[j] & 0x7FFFFFFF));
  168.     }
  169.  
  170.     ////////////////////////////////////////////////////////////////////////
  171.     //
  172.     // CBR (sample based)
  173.     //
  174.     ////////////////////////////////////////////////////////////////////////
  175.  
  176.     static const Chunk kChunks3[]={
  177.         { 0x0000000000000000ULL, 0 },
  178.         { 0x0000000080000000ULL, 4 },
  179.         { 0x0000000100000000ULL, 8 },
  180.         { 0x0000000180000000ULL, 12 },
  181.         { 0x0000000200000000ULL, 16 },
  182.     };
  183.  
  184.     ari.Init(4);
  185.     AddChunks(ari, kChunks3);
  186.     ari.Finalize();
  187.  
  188.     TEST_ASSERT(ari.GetChunkCount() == 5);
  189.     TEST_ASSERT(ari.GetSampleCount() == 10);
  190.     TEST_ASSERT(ari.IsVBR() == false);
  191.  
  192.     for(int i=1; i<5; ++i) {
  193.         const Chunk& ch = kChunks3[i];
  194.         ari.FindSampleRange(it, i*(i-1)/2, 1); ari.GetNextSampleRange(it, chunkPos, offset, byteSize);
  195.         TEST_ASSERT(chunkPos == ch.pos);
  196.         TEST_ASSERT(offset == 0);
  197.         TEST_ASSERT(byteSize == ch.len);
  198.     }
  199.  
  200.     ari.FindSampleRange(it, 0, 100);
  201.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  202.     TEST_ASSERT(chunkPos == kChunks3[1].pos);
  203.     TEST_ASSERT(offset == 0);
  204.     TEST_ASSERT(byteSize == 4);
  205.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  206.     TEST_ASSERT(chunkPos == kChunks3[2].pos);
  207.     TEST_ASSERT(offset == 0);
  208.     TEST_ASSERT(byteSize == 8);
  209.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  210.     TEST_ASSERT(chunkPos == kChunks3[3].pos);
  211.     TEST_ASSERT(offset == 0);
  212.     TEST_ASSERT(byteSize == 12);
  213.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  214.     TEST_ASSERT(chunkPos == kChunks3[4].pos);
  215.     TEST_ASSERT(offset == 0);
  216.     TEST_ASSERT(byteSize == 16);
  217.     TEST_ASSERT(false == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  218.     
  219.     ari.FindSampleRange(it, 1, 100);
  220.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  221.     TEST_ASSERT(chunkPos == kChunks3[2].pos);
  222.     TEST_ASSERT(offset == 0);
  223.     TEST_ASSERT(byteSize == 8);
  224.  
  225.     ari.FindSampleRange(it, 2, 100);
  226.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  227.     TEST_ASSERT(chunkPos == kChunks3[2].pos);
  228.     TEST_ASSERT(offset == 4);
  229.     TEST_ASSERT(byteSize == 4);
  230.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  231.     TEST_ASSERT(chunkPos == kChunks3[3].pos);
  232.     TEST_ASSERT(offset == 0);
  233.     TEST_ASSERT(byteSize == 12);
  234.  
  235.     ari.FindSampleRange(it, 3, 100);
  236.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  237.     TEST_ASSERT(chunkPos == kChunks3[3].pos);
  238.     TEST_ASSERT(offset == 0);
  239.     TEST_ASSERT(byteSize == 12);
  240.  
  241.     ari.FindSampleRange(it, 4, 100);
  242.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  243.     TEST_ASSERT(chunkPos == kChunks3[3].pos);
  244.     TEST_ASSERT(offset == 4);
  245.     TEST_ASSERT(byteSize == 8);
  246.  
  247.     ////////////////////////////////////////////////////////////////////////
  248.     //
  249.     // VBR (sample based)
  250.     //
  251.     ////////////////////////////////////////////////////////////////////////
  252.  
  253.     static const Chunk kChunks4[]={
  254.         { 0x0000000000000000ULL, 384 },
  255.         { 0x0000000080000000ULL, 192 },
  256.         { 0x0000000100000000ULL, 576 },
  257.         { 0x0000000180000000ULL, 1152 },
  258.         { 0x0000000200000000ULL, 1024 },
  259.     };
  260.  
  261.     ari.Init(576);
  262.     AddChunks(ari, kChunks4);
  263.     ari.Finalize();
  264.  
  265.     TEST_ASSERT(ari.GetChunkCount() == 5);
  266.     TEST_ASSERT(ari.GetSampleCount() == 7);
  267.     TEST_ASSERT(ari.IsVBR() == true);
  268.  
  269.     ari.FindSampleRange(it, 0, 100);
  270.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  271.     TEST_ASSERT(chunkPos == kChunks3[0].pos);
  272.     TEST_ASSERT(offset == 0);
  273.     TEST_ASSERT(byteSize == 384);
  274.  
  275.     ari.FindSampleRange(it, 1, 100);
  276.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  277.     TEST_ASSERT(chunkPos == kChunks3[1].pos);
  278.     TEST_ASSERT(offset == 0);
  279.     TEST_ASSERT(byteSize == 192);
  280.  
  281.     ari.FindSampleRange(it, 2, 100);
  282.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  283.     TEST_ASSERT(chunkPos == kChunks3[2].pos);
  284.     TEST_ASSERT(offset == 0);
  285.     TEST_ASSERT(byteSize == 576);
  286.  
  287.     ari.FindSampleRange(it, 3, 100);
  288.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  289.     TEST_ASSERT(chunkPos == kChunks3[3].pos);
  290.     TEST_ASSERT(offset == 0);
  291.     TEST_ASSERT(byteSize == 576);
  292.  
  293.     ari.FindSampleRange(it, 4, 100);
  294.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  295.     TEST_ASSERT(chunkPos == kChunks3[3].pos);
  296.     TEST_ASSERT(offset == 576);
  297.     TEST_ASSERT(byteSize == 576);
  298.  
  299.     ari.FindSampleRange(it, 5, 100);
  300.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  301.     TEST_ASSERT(chunkPos == kChunks3[4].pos);
  302.     TEST_ASSERT(offset == 0);
  303.     TEST_ASSERT(byteSize == 576);
  304.  
  305.     ari.FindSampleRange(it, 6, 100);
  306.     TEST_ASSERT(true == ari.GetNextSampleRange(it, chunkPos, offset, byteSize));
  307.     TEST_ASSERT(chunkPos == kChunks3[4].pos);
  308.     TEST_ASSERT(offset == 576);
  309.     TEST_ASSERT(byteSize == 448);
  310.  
  311.     return 0;
  312. }
  313.  
  314.