home *** CD-ROM | disk | FTP | other *** search
/ MPEG Toolkit / MPEG Toolkit.iso / dos / mpegstat / util.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-01  |  22.0 KB  |  378 lines
  1. /* MPEGSTAT - analyzing tool for MPEG-I video streams
  2.  * 
  3.  * Technical University of Berlin, Germany, Dept. of Computer Science
  4.  * Tom Pfeifer - Multimedia systems project - pfeifer@fokus.gmd.de
  5.  *
  6.  * Jens Brettin, Harald Masche, Alexander Schulze, Dirk Schubert
  7.  *
  8.  * This program uses parts of the source code of the Berkeley MPEG player
  9.  *
  10.  * ---------------------------
  11.  *
  12.  * Copyright (c) 1993 Technical University of Berlin, Germany
  13.  *
  14.  * for the parts of the Berkeley player used:
  15.  *
  16.  * Copyright (c) 1992 The Regents of the University of California.
  17.  * All rights reserved.
  18.  *
  19.  * ---------------------------
  20.  *
  21.  * Permission to use, copy, modify, and distribute this software and its
  22.  * documentation for any purpose, without fee, and without written agreement is
  23.  * hereby granted, provided that the above copyright notices and the following
  24.  * two paragraphs appear in all copies of this software.
  25.  * 
  26.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA 
  27.  * or the Technical University of Berlin BE LIABLE TO ANY PARTY FOR
  28.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  29.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  30.  * CALIFORNIA or the Technical University of Berlin HAS BEEN ADVISED OF THE 
  31.  * POSSIBILITY OF SUCH DAMAGE.
  32.  * 
  33.  * THE UNIVERSITY OF CALIFORNIA and the Technical University of Berlin 
  34.  * SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
  35.  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  36.  * PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE 
  37.  * UNIVERSITY OF CALIFORNIA and the Technical University of Berlin HAVE NO 
  38.  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
  39.  * OR MODIFICATIONS.
  40.  */
  41. /* Status codes for bit stream i/o operations. */
  42.  
  43. #define NO_VID_STREAM -1
  44. #define UNDERFLOW -2
  45. #define OK 1
  46.  
  47. /* Size increment of extension data buffers. */
  48.  
  49. #define EXT_BUF_SIZE 1024
  50.  
  51. /* External declarations for bitstream i/o operations. */
  52. extern unsigned int bitMask[];
  53. extern unsigned int nBitMask[];
  54. extern unsigned int rBitMask[];
  55. extern unsigned int bitTest[];
  56.  
  57. /* External declarations of bitstream global variables. */
  58. extern unsigned int curBits;
  59. extern int bitOffset;
  60. extern int bufLength;
  61. extern unsigned int *bitBuffer;
  62.  
  63. /* Macro for updating bit counter */
  64. #define UPDATE_COUNT(numbits) bitCount += numbits
  65.  
  66. #ifdef NO_SANITY_CHECKS
  67. #define get_bits1(result)                                                 \
  68. {                                                                         \
  69.   UPDATE_COUNT(1);                                                        \
  70.   result = ((curBits & 0x80000000) != 0);                              \
  71.   curBits <<= 1;                                                          \
  72.   bitOffset++;                                                            \
  73.                                                                           \
  74.   if (bitOffset & 0x20) {                                                 \
  75.     bitOffset = 0;                                                        \
  76.     bitBuffer++;                                                          \
  77.     curBits = *bitBuffer;                                                 \
  78.     bufLength--;                                                          \
  79.   }                                                                       \
  80. }
  81.  
  82. #define get_bits2(result)                                                 \
  83. {                                                                         \
  84.   UPDATE_COUNT(2);                                                        \
  85.   bitOffset += 2;                                                         \
  86.                                                                           \
  87.   if (bitOffset & 0x20) {                                                 \
  88.     bitOffset -= 32;                                                      \
  89.     bitBuffer++;                                                          \
  90.     bufLength--;                                                          \
  91.     if (bitOffset) {                                                      \
  92.       curBits |= (*bitBuffer >> (2 - bitOffset));                         \
  93.     }                                                                     \
  94.     result = ((curBits & 0xc0000000) >> 30);                           \
  95.     curBits = *bitBuffer << bitOffset;                                    \
  96.   }                                                                       \
  97.                                                                           \
  98.   result = ((curBits & 0xc0000000) >> 30);                             \
  99.   curBits <<= 2;                                                          \
  100. }
  101.  
  102. #define get_bitsX(num, mask, shift,  result)                              \
  103. {                                                                         \
  104.   UPDATE_COUNT(num);                                                      \
  105.   bitOffset += num;                                                       \
  106.                                                                           \
  107.   if (bitOffset & 0x20) {                                                 \
  108.     bitOffset -= 32;                                                      \
  109.     bitBuffer++;                                                          \
  110.     bufLength--;                                                          \
  111.     if (bitOffset) {                                                      \
  112.       curBits |= (*bitBuffer >> (num - bitOffset));                       \
  113.     }                                                                     \
  114.     result = ((curBits & mask) >> shift);                              \
  115.     curBits = *bitBuffer << bitOffset;                                    \
  116.   }                                                                       \
  117.   else {                                                                  \
  118.     result = ((curBits & mask) >> shift);                              \
  119.     curBits <<= num;                                                      \
  120.   }                                                                       \
  121. }
  122. #else
  123.  
  124. #define get_bits1(result)                                                 \
  125. {                                                                         \
  126.   /* Check for underflow. */                                              \
  127.                                                                           \
  128.   if (bufLength < 2) {                                                    \
  129.     correct_underflow();                                                  \
  130.   }                                                                       \
  131.   UPDATE_COUNT(1);                                                        \
  132.   result = ((curBits & 0x80000000) != 0);                              \
  133.   curBits <<= 1;                                                          \
  134.   bitOffset++;                                                            \
  135.                                                                           \
  136.   if (bitOffset & 0x20) {                                                 \
  137.     bitOffset = 0;                                                        \
  138.     bitBuffer++;                                                          \
  139.     curBits = *bitBuffer;                                                 \
  140.     bufLength--;                                                          \
  141.   }                                                                       \
  142. }
  143.  
  144. #define get_bits2(result)                                                 \
  145. {                                                                         \
  146.   /* Check for underflow. */                                              \
  147.                                                                           \
  148.   if (bufLength < 2) {                                                    \
  149.     correct_underflow();                                                  \
  150.   }                                                                       \
  151.   UPDATE_COUNT(2);                                                        \
  152.   bitOffset += 2;                                                         \
  153.                                                                           \
  154.   if (bitOffset & 0x20) {                                                 \
  155.     bitOffset -= 32;                                                      \
  156.     bitBuffer++;                                                          \
  157.     bufLength--;                                                          \
  158.     if (bitOffset) {                                                      \
  159.       curBits |= (*bitBuffer >> (2 - bitOffset));                         \
  160.     }                                                                     \
  161.     result = ((curBits & 0xc0000000) >> 30);                           \
  162.     curBits = *bitBuffer << bitOffset;                                    \
  163.   }                                                                       \
  164.                                                                           \
  165.   result = ((curBits & 0xc0000000) >> 30);                             \
  166.   curBits <<= 2;                                                          \
  167. }
  168.  
  169. #define get_bitsX(num, mask, shift,  result)                              \
  170. {                                                                         \
  171.   /* Check for underflow. */                                              \
  172.                                                                           \
  173.   if (bufLength < 2) {                                                    \
  174.     correct_underflow();                                                  \
  175.   }                                                                       \
  176.   UPDATE_COUNT(num);                                                      \
  177.   bitOffset += num;                                                       \
  178.                                                                           \
  179.   if (bitOffset & 0x20) {                                                 \
  180.     bitOffset -= 32;                                                      \
  181.     bitBuffer++;                                                          \
  182.     bufLength--;                                                          \
  183.     if (bitOffset) {                                                      \
  184.       curBits |= (*bitBuffer >> (num - bitOffset));                       \
  185.     }                                                                     \
  186.     result = ((curBits & mask) >> shift);                              \
  187.     curBits = *bitBuffer << bitOffset;                                    \
  188.   }                                                                       \
  189.   else {                                                                  \
  190.    result = ((curBits & mask) >> shift);                               \
  191.    curBits <<= num;                                                       \
  192.   }                                                                       \
  193. }
  194. #endif
  195.  
  196. #define get_bits3(result) get_bitsX(3,   0xe0000000, 29, result)
  197. #define get_bits4(result) get_bitsX(4,   0xf0000000, 28, result)
  198. #define get_bits5(result) get_bitsX(5,   0xf8000000, 27, result)
  199. #define get_bits6(result) get_bitsX(6,   0xfc000000, 26, result)
  200. #define get_bits7(result) get_bitsX(7,   0xfe000000, 25, result)
  201. #define get_bits8(result) get_bitsX(8,   0xff000000, 24, result)
  202. #define get_bits9(result) get_bitsX(9,   0xff800000, 23, result)
  203. #define get_bits10(result) get_bitsX(10, 0xffc00000, 22, result)
  204. #define get_bits11(result) get_bitsX(11, 0xffe00000, 21, result)
  205. #define get_bits12(result) get_bitsX(12, 0xfff00000, 20, result)
  206. #define get_bits14(result) get_bitsX(14, 0xfffc0000, 18, result)
  207. #define get_bits16(result) get_bitsX(16, 0xffff0000, 16, result)
  208. #define get_bits18(result) get_bitsX(18, 0xffffc000, 14, result)
  209. #define get_bits32(result) get_bitsX(32, 0xffffffff,  0, result)
  210.  
  211. #define get_bitsn(num, result) get_bitsX((num), nBitMask[num], (32-(num)), result)
  212.  
  213. #ifdef NO_SANITY_CHECKS
  214. #define show_bits32(result)                                      \
  215. {                                                                       \
  216.   if (bitOffset) {                            \
  217.     result = curBits | (*(bitBuffer+1) >> (32 - bitOffset));        \
  218.   }                                                                     \
  219.   else {                                                                \
  220.     result = curBits;                            \
  221.   }                                                                     \
  222. }
  223.  
  224. #define show_bitsX(num, mask, shift,  result)                           \
  225. {                                                                       \
  226.   int bO;                                                               \
  227.   bO = bitOffset + num;                                                 \
  228.   if (bO > 32) {                                                        \
  229.     bO -= 32;                                                           \
  230.     result = ((curBits & mask) >> shift) |                              \
  231.                 (*(bitBuffer+1) >> (shift + (num - bO)));               \
  232.   }                                                                     \
  233.   else {                                                                \
  234.     result = ((curBits & mask) >> shift);                               \
  235.   }                                                                     \
  236. }
  237.  
  238. #else
  239. #define show_bits32(result)                                       \
  240. {                                                                       \
  241.   /* Check for underflow. */                                            \
  242.   if (bufLength < 2) {                                                  \
  243.     correct_underflow();                                                \
  244.   }                                                                     \
  245.   if (bitOffset) {                            \
  246.     result = curBits | (*(bitBuffer+1) >> (32 - bitOffset));        \
  247.   }                                                                     \
  248.   else {                                                                \
  249.     result = curBits;                            \
  250.   }                                                                     \
  251. }
  252.  
  253. #define show_bitsX(num, mask, shift, result)                            \
  254. {                                                                       \
  255.   int bO;                                                               \
  256.                                                                         \
  257.   /* Check for underflow. */                                            \
  258.   if (bufLength < 2) {                                                  \
  259.     correct_underflow();                                                \
  260.   }                                                                     \
  261.   bO = bitOffset + num;                                                 \
  262.   if (bO > 32) {                                                        \
  263.     bO -= 32;                                                           \
  264.     result = ((curBits & mask) >> shift) |                              \
  265.                 (*(bitBuffer+1) >> (shift + (num - bO)));               \
  266.   }                                                                     \
  267.   else {                                                                \
  268.     result = ((curBits & mask) >> shift);                               \
  269.   }                                                                     \
  270. }
  271. #endif
  272.  
  273. #define show_bits1(result)  show_bitsX(1,  0x80000000, 31, result)
  274. #define show_bits2(result)  show_bitsX(2,  0xc0000000, 30, result)
  275. #define show_bits3(result)  show_bitsX(3,  0xe0000000, 29, result)
  276. #define show_bits4(result)  show_bitsX(4,  0xf0000000, 28, result)
  277. #define show_bits5(result)  show_bitsX(5,  0xf8000000, 27, result)
  278. #define show_bits6(result)  show_bitsX(6,  0xfc000000, 26, result)
  279. #define show_bits7(result)  show_bitsX(7,  0xfe000000, 25, result)
  280. #define show_bits8(result)  show_bitsX(8,  0xff000000, 24, result)
  281. #define show_bits9(result)  show_bitsX(9,  0xff800000, 23, result)
  282. #define show_bits10(result) show_bitsX(10, 0xffc00000, 22, result)
  283. #define show_bits11(result) show_bitsX(11, 0xffe00000, 21, result)
  284. #define show_bits12(result) show_bitsX(12, 0xfff00000, 20, result)
  285. #define show_bits13(result) show_bitsX(13, 0xfff80000, 19, result)
  286. #define show_bits14(result) show_bitsX(14, 0xfffc0000, 18, result)
  287. #define show_bits15(result) show_bitsX(15, 0xfffe0000, 17, result)
  288. #define show_bits16(result) show_bitsX(16, 0xffff0000, 16, result)
  289. #define show_bits17(result) show_bitsX(17, 0xffff8000, 15, result)
  290. #define show_bits18(result) show_bitsX(18, 0xffffc000, 14, result)
  291. #define show_bits19(result) show_bitsX(19, 0xffffe000, 13, result)
  292. #define show_bits20(result) show_bitsX(20, 0xfffff000, 12, result)
  293. #define show_bits21(result) show_bitsX(21, 0xfffff800, 11, result)
  294. #define show_bits22(result) show_bitsX(22, 0xfffffc00, 10, result)
  295. #define show_bits23(result) show_bitsX(23, 0xfffffe00,  9, result)
  296. #define show_bits24(result) show_bitsX(24, 0xffffff00,  8, result)
  297. #define show_bits25(result) show_bitsX(25, 0xffffff80,  7, result)
  298. #define show_bits26(result) show_bitsX(26, 0xffffffc0,  6, result)
  299. #define show_bits27(result) show_bitsX(27, 0xffffffe0,  5, result)
  300. #define show_bits28(result) show_bitsX(28, 0xfffffff0,  4, result)
  301. #define show_bits29(result) show_bitsX(29, 0xfffffff8,  3, result)
  302. #define show_bits30(result) show_bitsX(30, 0xfffffffc,  2, result)
  303. #define show_bits31(result) show_bitsX(31, 0xfffffffe,  1, result)
  304.  
  305. #define show_bitsn(num,result) show_bitsX((num), (0xffffffff << (32-(num))), (32-(num)), result)
  306.  
  307. #ifdef NO_SANITY_CHECKS
  308. #define flush_bits32                                                  \
  309. {                                                                     \
  310.   UPDATE_COUNT(32);                                                   \
  311.                                                                       \
  312.   bitBuffer++;                                                        \
  313.   bufLength--;                                                        \
  314.   curBits = *bitBuffer  << bitOffset;                                 \
  315. }
  316.  
  317. #define flush_bits(num)                                               \
  318. {                                                                     \
  319.   bitOffset += num;                                                   \
  320.                                                                       \
  321.   UPDATE_COUNT(num);                                                  \
  322.                                                                       \
  323.   if (bitOffset & 0x20) {                                             \
  324.     bitOffset -= 32;                                                  \
  325.     bitBuffer++;                                                      \
  326.     bufLength--;                                                      \
  327.     curBits = *bitBuffer  << bitOffset;                               \
  328.   }                                                                   \
  329.   else {                                                              \
  330.     curBits <<= num;                                                  \
  331.   }                                                                   \
  332. }
  333. #else
  334. #define flush_bits32                                                  \
  335. {                                                                     \
  336.   if (curVidStream == NULL) {                                         \
  337.     /* Deal with no vid stream here. */                               \
  338.   }                                                                   \
  339.                                                                       \
  340.   if (bufLength < 2) {                                                \
  341.     correct_underflow();                                              \
  342.   }                                                                   \
  343.                                                                       \
  344.   UPDATE_COUNT(32);                                                   \
  345.                                                                       \
  346.   bitBuffer++;                                                        \
  347.   bufLength--;                                                        \
  348.   curBits = *bitBuffer  << bitOffset;                                 \
  349. }
  350.  
  351. #define flush_bits(num)                                               \
  352. {                                                                     \
  353.   if (curVidStream == NULL) {                                         \
  354.     /* Deal with no vid stream here. */                               \
  355.   }                                                                   \
  356.                                                                       \
  357.   if (bufLength < 2) {                                                \
  358.     correct_underflow();                                              \
  359.   }                                                                   \
  360.                                                                       \
  361.   UPDATE_COUNT(num);                                                  \
  362.                                                                       \
  363.   bitOffset += num;                                                   \
  364.                                                                       \
  365.   if (bitOffset & 0x20) {                                             \
  366.     bufLength--;                                                      \
  367.     bitOffset -= 32;                                                  \
  368.     bitBuffer++;                                                      \
  369.     curBits = *bitBuffer << bitOffset;                                \
  370.   }                                                                   \
  371.   else {                                                              \
  372.     curBits <<= num;                                                  \
  373.   }                                                                   \
  374. }
  375. #endif
  376.  
  377. #define UTIL2
  378.