PageRenderTime 212ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 1ms

/Show/avc/vlc.cpp

http://github.com/mbebenita/Broadway
C++ | 815 lines | 653 code | 124 blank | 38 comment | 119 complexity | 62d44909fd3ce5815184b43ea43e87db MD5 | raw file
Possible License(s): BSD-3-Clause 
    

  1. /* ------------------------------------------------------------------
    2. 

  2.  * Copyright (C) 1998-2009 PacketVideo
    3. 

  3.  *
    4. 

  4.  * Licensed under the Apache License, Version 2.0 (the "License");
    5. 

  5.  * you may not use this file except in compliance with the License.
    6. 

  6.  * You may obtain a copy of the License at
    7. 

  7.  *
    8. 

  8.  *      http://www.apache.org/licenses/LICENSE-2.0
    9. 

  9.  *
    10. 

  10.  * Unless required by applicable law or agreed to in writing, software
    11. 

  11.  * distributed under the License is distributed on an "AS IS" BASIS,
    12. 

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
    13. 

  13.  * express or implied.
    14. 

  14.  * See the License for the specific language governing permissions
    15. 

  15.  * and limitations under the License.
    16. 

  16.  * -------------------------------------------------------------------
    17. 

  17.  */
    18. 

  18. #include "avcdec_lib.h"
    19. 

  19. #include "avcdec_bitstream.h"
    20. 

  20. 

  21. //#define PV_ARM_V5
    22. 

  22. #ifdef PV_ARM_V5
    23. 

  23. #define PV_CLZ(A,B) __asm{CLZ (A),(B)}  \
    24. 

  24.     A -= 16;
    25. 

  25. #else
    26. 

  26. #define PV_CLZ(A,B) while (((B) & 0x8000) == 0) {(B) <<=1; A++;}
    27. 

  27. #endif
    28. 

  28. 

  29. 

  30. #define PV_NO_CLZ
    31. 

  31. 

  32. #ifndef PV_NO_CLZ
    33. 

  33. typedef struct tagVLCNumCoeffTrail
    34. 

  34. {
    35. 

  35.     int trailing;
    36. 

  36.     int total_coeff;
    37. 

  37.     int length;
    38. 

  38. } VLCNumCoeffTrail;
    39. 

  39. 

  40. typedef struct tagShiftOffset
    41. 

  41. {
    42. 

  42.     int shift;
    43. 

  43.     int offset;
    44. 

  44. } ShiftOffset;
    45. 

  45. 

  46. const VLCNumCoeffTrail NumCoeffTrailOnes[3][67] =
    47. 

  47. {
    48. 

  48.     {{0, 0, 1}, {1, 1, 2}, {2, 2, 3}, {1, 2, 6}, {0, 1, 6}, {3, 3, 5}, {3, 3, 5}, {3, 5, 7},
    49. 

  49.         {2, 3, 7}, {3, 4, 6}, {3, 4, 6}, {3, 6, 8}, {2, 4, 8}, {1, 3, 8}, {0, 2, 8}, {3, 7, 9},
    50. 

  50.         {2, 5, 9}, {1, 4, 9}, {0, 3, 9}, {3, 8, 10}, {2, 6, 10}, {1, 5, 10}, {0, 4, 10}, {3, 9, 11},
    51. 

  51.         {2, 7, 11}, {1, 6, 11}, {0, 5, 11}, {0, 8, 13}, {2, 9, 13}, {1, 8, 13}, {0, 7, 13}, {3, 10, 13},
    52. 

  52.         {2, 8, 13}, {1, 7, 13}, {0, 6, 13}, {3, 12, 14}, {2, 11, 14}, {1, 10, 14}, {0, 10, 14}, {3, 11, 14},
    53. 

  53.         {2, 10, 14}, {1, 9, 14}, {0, 9, 14}, {3, 14, 15}, {2, 13, 15}, {1, 12, 15}, {0, 12, 15}, {3, 13, 15},
    54. 

  54.         {2, 12, 15}, {1, 11, 15}, {0, 11, 15}, {3, 16, 16}, {2, 15, 16}, {1, 15, 16}, {0, 14, 16}, {3, 15, 16},
    55. 

  55.         {2, 14, 16}, {1, 14, 16}, {0, 13, 16}, {0, 16, 16}, {2, 16, 16}, {1, 16, 16}, {0, 15, 16}, {1, 13, 15},
    56. 

  56.         { -1, -1, -1}, { -1, -1, -1}, { -1, -1, -1}},
    57. 

  57. 

  58.     {{1, 1, 2}, {0, 0, 2}, {3, 4, 4}, {3, 3, 4}, {2, 2, 3}, {2, 2, 3}, {3, 6, 6}, {2, 3, 6},
    59. 

  59.         {1, 3, 6}, {0, 1, 6}, {3, 5, 5}, {3, 5, 5}, {1, 2, 5}, {1, 2, 5}, {3, 7, 6}, {2, 4, 6},
    60. 

  60.         {1, 4, 6}, {0, 2, 6}, {3, 8, 7}, {2, 5, 7}, {1, 5, 7}, {0, 3, 7}, {0, 5, 8}, {2, 6, 8},
    61. 

  61.         {1, 6, 8}, {0, 4, 8}, {3, 9, 9}, {2, 7, 9}, {1, 7, 9}, {0, 6, 9}, {3, 11, 11}, {2, 9, 11},
    62. 

  62.         {1, 9, 11}, {0, 8, 11}, {3, 10, 11}, {2, 8, 11}, {1, 8, 11}, {0, 7, 11}, {0, 11, 12}, {2, 11, 12},
    63. 

  63.         {1, 11, 12}, {0, 10, 12}, {3, 12, 12}, {2, 10, 12}, {1, 10, 12}, {0, 9, 12}, {3, 14, 13}, {2, 13, 13},
    64. 

  64.         {1, 13, 13}, {0, 13, 13}, {3, 13, 13}, {2, 12, 13}, {1, 12, 13}, {0, 12, 13}, {1, 15, 14}, {0, 15, 14},
    65. 

  65.         {2, 15, 14}, {1, 14, 14}, {2, 14, 13}, {2, 14, 13}, {0, 14, 13}, {0, 14, 13}, {3, 16, 14}, {2, 16, 14},
    66. 

  66.         {1, 16, 14}, {0, 16, 14}, {3, 15, 13}},
    67. 

  67. 

  68.     {{3, 7, 4}, {3, 6, 4}, {3, 5, 4}, {3, 4, 4}, {3, 3, 4}, {2, 2, 4}, {1, 1, 4}, {0, 0, 4},
    69. 

  69.         {1, 5, 5}, {2, 5, 5}, {1, 4, 5}, {2, 4, 5}, {1, 3, 5}, {3, 8, 5}, {2, 3, 5}, {1, 2, 5},
    70. 

  70.         {0, 3, 6}, {2, 7, 6}, {1, 7, 6}, {0, 2, 6}, {3, 9, 6}, {2, 6, 6}, {1, 6, 6}, {0, 1, 6},
    71. 

  71.         {0, 7, 7}, {0, 6, 7}, {2, 9, 7}, {0, 5, 7}, {3, 10, 7}, {2, 8, 7}, {1, 8, 7}, {0, 4, 7},
    72. 

  72.         {3, 12, 8}, {2, 11, 8}, {1, 10, 8}, {0, 9, 8}, {3, 11, 8}, {2, 10, 8}, {1, 9, 8}, {0, 8, 8},
    73. 

  73.         {0, 12, 9}, {2, 13, 9}, {1, 12, 9}, {0, 11, 9}, {3, 13, 9}, {2, 12, 9}, {1, 11, 9}, {0, 10, 9},
    74. 

  74.         {1, 15, 10}, {0, 14, 10}, {3, 14, 10}, {2, 14, 10}, {1, 14, 10}, {0, 13, 10}, {1, 13, 9}, {1, 13, 9},
    75. 

  75.         {1, 16, 10}, {0, 15, 10}, {3, 15, 10}, {2, 15, 10}, {3, 16, 10}, {2, 16, 10}, {0, 16, 10}, { -1, -1, -1},
    76. 

  76.         { -1, -1, -1}, { -1, -1, -1}, { -1, -1, -1}}
    77. 

  77. };
    78. 

  78. 

  79. 

  80. const ShiftOffset NumCoeffTrailOnes_indx[3][15] =
    81. 

  81. {
    82. 

  82.     {{15, -1}, {14, 0}, {13, 1}, {10, -1}, {9, 3}, {8, 7}, {7, 11}, {6, 15},
    83. 

  83.         {5, 19}, {3, 19}, {2, 27}, {1, 35}, {0, 43}, {0, 55}, {1, 62}},
    84. 

  84. 

  85.     {{14, -2}, {12, -2}, {10, -2}, {10, 10}, {9, 14}, {8, 18}, {7, 22}, {5, 22},
    86. 

  86.         {4, 30}, {3, 38}, {2, 46}, {2, 58}, {3, 65}, {16, 0}, {16, 0}},
    87. 

  87. 

  88.     {{12, -8}, {11, 0}, {10, 8}, {9, 16}, {8, 24}, {7, 32}, {6, 40}, {6, 52},
    89. 

  89.         {6, 58}, {6, 61}, {16, 0}, {16, 0}, {16, 0}, {16, 0}, {16, 0}}
    90. 

  90. };
    91. 

  91. 

  92. const static int nC_table[8] = {0, 0, 1, 1, 2, 2, 2, 2};
    93. 

  93. 

  94. #endif
    95. 

  95. /**
    96. 

  96. See algorithm in subclause 9.1, Table 9-1, Table 9-2. */
    97. 

  97. AVCDec_Status ue_v(AVCDecBitstream *bitstream, uint *codeNum)
    98. 

  98. {
    99. 

  99.     uint temp, tmp_cnt;
    100. 

  100.     int leading_zeros = 0;
    101. 

  101.     BitstreamShowBits(bitstream, 16, &temp);
    102. 

  102.     tmp_cnt = temp  | 0x1;
    103. 

  103. 

  104.     PV_CLZ(leading_zeros, tmp_cnt)
    105. 

  105. 

  106.     if (leading_zeros < 8)
    107. 

  107.     {
    108. 

  108.         *codeNum = (temp >> (15 - (leading_zeros << 1))) - 1;
    109. 

  109.         BitstreamFlushBits(bitstream, (leading_zeros << 1) + 1);
    110. 

  110.     }
    111. 

  111.     else
    112. 

  112.     {
    113. 

  113.         BitstreamReadBits(bitstream, (leading_zeros << 1) + 1, &temp);
    114. 

  114.         *codeNum = temp - 1;
    115. 

  115.     }
    116. 

  116. 

  117.     return AVCDEC_SUCCESS;
    118. 

  118. }
    119. 

  119. 

  120. /**
    121. 

  121. See subclause 9.1.1, Table 9-3 */
    122. 

  122. AVCDec_Status  se_v(AVCDecBitstream *bitstream, int *value)
    123. 

  123. {
    124. 

  124.     uint temp, tmp_cnt;
    125. 

  125.     int leading_zeros = 0;
    126. 

  126.     BitstreamShowBits(bitstream, 16, &temp);
    127. 

  127.     tmp_cnt = temp | 0x1;
    128. 

  128. 

  129.     PV_CLZ(leading_zeros, tmp_cnt)
    130. 

  130. 

  131.     if (leading_zeros < 8)
    132. 

  132.     {
    133. 

  133.         temp >>= (15 - (leading_zeros << 1));
    134. 

  134.         BitstreamFlushBits(bitstream, (leading_zeros << 1) + 1);
    135. 

  135.     }
    136. 

  136.     else
    137. 

  137.     {
    138. 

  138.         BitstreamReadBits(bitstream, (leading_zeros << 1) + 1, &temp);
    139. 

  139.     }
    140. 

  140. 

  141.     *value = temp >> 1;
    142. 

  142. 

  143.     if (temp & 0x01)                          // lsb is signed bit
    144. 

  144.         *value = -(*value);
    145. 

  145. 

  146. //  leading_zeros = temp >> 1;
    147. 

  147. //  *value = leading_zeros - (leading_zeros*2*(temp&1));
    148. 

  148. 

  149.     return AVCDEC_SUCCESS;
    150. 

  150. }
    151. 

  151. 

  152. AVCDec_Status  se_v32bit(AVCDecBitstream *bitstream, int32 *value)
    153. 

  153. {
    154. 

  154.     int leadingZeros;
    155. 

  155.     uint32 infobits;
    156. 

  156.     uint32 codeNum;
    157. 

  157. 

  158.     if (AVCDEC_SUCCESS != GetEGBitstring32bit(bitstream, &leadingZeros, &infobits))
    159. 

  159.         return AVCDEC_FAIL;
    160. 

  160. 

  161.     codeNum = (1 << leadingZeros) - 1 + infobits;
    162. 

  162. 

  163.     *value = (codeNum + 1) / 2;
    164. 

  164. 

  165.     if ((codeNum & 0x01) == 0)                        // lsb is signed bit
    166. 

  166.         *value = -(*value);
    167. 

  167. 

  168.     return AVCDEC_SUCCESS;
    169. 

  169. }
    170. 

  170. 

  171. 

  172. AVCDec_Status te_v(AVCDecBitstream *bitstream, uint *value, uint range)
    173. 

  173. {
    174. 

  174.     if (range > 1)
    175. 

  175.     {
    176. 

  176.         ue_v(bitstream, value);
    177. 

  177.     }
    178. 

  178.     else
    179. 

  179.     {
    180. 

  180.         BitstreamRead1Bit(bitstream, value);
    181. 

  181.         *value = 1 - (*value);
    182. 

  182.     }
    183. 

  183.     return AVCDEC_SUCCESS;
    184. 

  184. }
    185. 

  185. 

  186. 

  187. 

  188. /* This function is only used for syntax with range from -2^31 to 2^31-1 */
    189. 

  189. /* only a few of them in the SPS and PPS */
    190. 

  190. AVCDec_Status GetEGBitstring32bit(AVCDecBitstream *bitstream, int *leadingZeros, uint32 *infobits)
    191. 

  191. {
    192. 

  192.     int bit_value;
    193. 

  193.     uint info_temp;
    194. 

  194. 

  195.     *leadingZeros = 0;
    196. 

  196. 

  197.     BitstreamRead1Bit(bitstream, (uint*)&bit_value);
    198. 

  198. 

  199.     while (!bit_value)
    200. 

  200.     {
    201. 

  201.         (*leadingZeros)++;
    202. 

  202.         BitstreamRead1Bit(bitstream, (uint*)&bit_value);
    203. 

  203.     }
    204. 

  204. 

  205.     if (*leadingZeros > 0)
    206. 

  206.     {
    207. 

  207.         if (sizeof(uint) == 4)  /* 32 bit machine */
    208. 

  208.         {
    209. 

  209.             BitstreamReadBits(bitstream, *leadingZeros, (uint*)&info_temp);
    210. 

  210.             *infobits = (uint32)info_temp;
    211. 

  211.         }
    212. 

  212.         else if (sizeof(uint) == 2) /* 16 bit machine */
    213. 

  213.         {
    214. 

  214.             *infobits = 0;
    215. 

  215.             if (*leadingZeros > 16)
    216. 

  216.             {
    217. 

  217.                 BitstreamReadBits(bitstream, 16, (uint*)&info_temp);
    218. 

  218.                 (*leadingZeros) -= 16;
    219. 

  219.                 *infobits = ((uint32)info_temp) << (*leadingZeros);
    220. 

  220.             }
    221. 

  221. 

  222.             BitstreamReadBits(bitstream, *leadingZeros, (uint*)&info_temp);
    223. 

  223.             *infobits |= (uint32)info_temp ;
    224. 

  224.         }
    225. 

  225.     }
    226. 

  226.     else
    227. 

  227.         *infobits = 0;
    228. 

  228. 

  229.     return AVCDEC_SUCCESS;
    230. 

  230. }
    231. 

  231. 

  232. /* see Table 9-4 assignment of codeNum to values of coded_block_pattern. */
    233. 

  233. const static uint8 MapCBP[48][2] =
    234. 

  234. {
    235. 

  235.     {47, 0}, {31, 16}, {15, 1}, { 0, 2}, {23, 4}, {27, 8}, {29, 32}, {30, 3}, { 7, 5}, {11, 10}, {13, 12}, {14, 15},
    236. 

  236.     {39, 47}, {43, 7}, {45, 11}, {46, 13}, {16, 14}, { 3, 6}, { 5, 9}, {10, 31}, {12, 35}, {19, 37}, {21, 42}, {26, 44},
    237. 

  237.     {28, 33}, {35, 34}, {37, 36}, {42, 40}, {44, 39}, { 1, 43}, { 2, 45}, { 4, 46}, { 8, 17}, {17, 18}, {18, 20}, {20, 24},
    238. 

  238.     {24, 19}, { 6, 21}, { 9, 26}, {22, 28}, {25, 23}, {32, 27}, {33, 29}, {34, 30}, {36, 22}, {40, 25}, {38, 38}, {41, 41},
    239. 

  239. };
    240. 

  240. 

  241. AVCDec_Status DecodeCBP(AVCMacroblock *currMB, AVCDecBitstream *stream)
    242. 

  242. {
    243. 

  243.     uint codeNum;
    244. 

  244.     uint coded_block_pattern;
    245. 

  245. 

  246.     ue_v(stream, &codeNum);
    247. 

  247. 

  248.     if (codeNum > 47)
    249. 

  249.     {
    250. 

  250.         return AVCDEC_FAIL;
    251. 

  251.     }
    252. 

  252. 

  253.     /* can get rid of the if _OPTIMIZE */
    254. 

  254.     if (currMB->mbMode == AVC_I4)
    255. 

  255.     {
    256. 

  256.         coded_block_pattern = MapCBP[codeNum][0];
    257. 

  257.     }
    258. 

  258.     else
    259. 

  259.     {
    260. 

  260.         coded_block_pattern = MapCBP[codeNum][1];
    261. 

  261.     }
    262. 

  262. 

  263. //  currMB->cbpL = coded_block_pattern&0xF;  /* modulo 16 */
    264. 

  264. //  currMB->cbpC = coded_block_pattern>>4;   /* divide 16 */
    265. 

  265.     currMB->CBP = coded_block_pattern;
    266. 

  266. 

  267.     return AVCDEC_SUCCESS;
    268. 

  268. }
    269. 

  269. 

  270. 

  271. /* TO BE OPTIMIZED !!!!! */
    272. 

  272. AVCDec_Status ce_TotalCoeffTrailingOnes(AVCDecBitstream *stream, int *TrailingOnes, int *TotalCoeff, int nC)
    273. 

  273. {
    274. 

  274. #ifdef PV_NO_CLZ
    275. 

  275.     const static uint8 TotCofNTrail1[75][3] = {{0, 0, 16}/*error */, {0, 0, 16}/*error */, {1, 13, 15}, {1, 13, 15}, {0, 16, 16}, {2, 16, 16}, {1, 16, 16}, {0, 15, 16},
    276. 

  276.         {3, 16, 16}, {2, 15, 16}, {1, 15, 16}, {0, 14, 16}, {3, 15, 16}, {2, 14, 16}, {1, 14, 16}, {0, 13, 16},
    277. 

  277.         {3, 14, 15}, {2, 13, 15}, {1, 12, 15}, {0, 12, 15}, {3, 13, 15}, {2, 12, 15}, {1, 11, 15}, {0, 11, 15},
    278. 

  278.         {3, 12, 14}, {2, 11, 14}, {1, 10, 14}, {0, 10, 14}, {3, 11, 14}, {2, 10, 14}, {1, 9, 14}, {0, 9, 14},
    279. 

  279.         {0, 8, 13}, {2, 9, 13}, {1, 8, 13}, {0, 7, 13}, {3, 10, 13}, {2, 8, 13}, {1, 7, 13}, {0, 6, 13},
    280. 

  280.         {3, 9, 11}, {2, 7, 11}, {1, 6, 11}, {0, 5, 11}, {3, 8, 10},
    281. 

  281.         {2, 6, 10}, {1, 5, 10}, {0, 4, 10}, {3, 7, 9}, {2, 5, 9}, {1, 4, 9}, {0, 3, 9}, {3, 6, 8},
    282. 

  282.         {2, 4, 8}, {1, 3, 8}, {0, 2, 8}, {3, 5, 7}, {2, 3, 7}, {3, 4, 6}, {3, 4, 6}, {1, 2, 6},
    283. 

  283.         {1, 2, 6}, {0, 1, 6}, {0, 1, 6}, {3, 3, 5}, {3, 3, 5}, {3, 3, 5}, {3, 3, 5}, {2, 2, 3},
    284. 

  284.         {1, 1, 2}, {1, 1, 2}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1}
    285. 

  285.     };
    286. 

  286. 

  287.     const static uint8 TotCofNTrail2[84][3] = {{0, 0, 14 /* error */}, {0, 0, 14/*error */}, {3, 15, 13}, {3, 15, 13}, {3, 16, 14}, {2, 16, 14}, {1, 16, 14}, {0, 16, 14},
    288. 

  288.         {1, 15, 14}, {0, 15, 14}, {2, 15, 14}, {1, 14, 14}, {2, 14, 13}, {2, 14, 13}, {0, 14, 13}, {0, 14, 13},
    289. 

  289.         {3, 14, 13}, {2, 13, 13}, {1, 13, 13}, {0, 13, 13}, {3, 13, 13}, {2, 12, 13}, {1, 12, 13}, {0, 12, 13},
    290. 

  290.         {0, 11, 12}, {2, 11, 12}, {1, 11, 12}, {0, 10, 12}, {3, 12, 12}, {2, 10, 12}, {1, 10, 12}, {0, 9, 12},
    291. 

  291.         {3, 11, 11}, {2, 9, 11}, {1, 9, 11}, {0, 8, 11}, {3, 10, 11}, {2, 8, 11}, {1, 8, 11}, {0, 7, 11},
    292. 

  292.         {3, 9, 9}, {2, 7, 9}, {1, 7, 9}, {0, 6, 9}, {0, 5, 8}, {0, 5, 8}, {2, 6, 8}, {2, 6, 8},
    293. 

  293.         {1, 6, 8}, {1, 6, 8}, {0, 4, 8}, {0, 4, 8}, {3, 8, 7}, {2, 5, 7}, {1, 5, 7}, {0, 3, 7},
    294. 

  294.         {3, 7, 6}, {3, 7, 6}, {2, 4, 6}, {2, 4, 6}, {1, 4, 6}, {1, 4, 6}, {0, 2, 6}, {0, 2, 6},
    295. 

  295.         {3, 6, 6}, {2, 3, 6}, {1, 3, 6}, {0, 1, 6}, {3, 5, 5}, {3, 5, 5}, {1, 2, 5}, {1, 2, 5},
    296. 

  296.         {3, 4, 4}, {3, 3, 4}, {2, 2, 3}, {2, 2, 3}, {1, 1, 2}, {1, 1, 2}, {1, 1, 2}, {1, 1, 2},
    297. 

  297.         {0, 0, 2}, {0, 0, 2}, {0, 0, 2}, {0, 0, 2}
    298. 

  298.     };
    299. 

  299. 

  300.     const static uint8 TotCofNTrail3[64][3] = {{0, 0, 10/*error*/}, {0, 16, 10}, {3, 16, 10}, {2, 16, 10}, {1, 16, 10}, {0, 15, 10}, {3, 15, 10},
    301. 

  301.         {2, 15, 10}, {1, 15, 10}, {0, 14, 10}, {3, 14, 10}, {2, 14, 10}, {1, 14, 10}, {0, 13, 10}, {1, 13, 9},
    302. 

  302.         {1, 13, 9}, {0, 12, 9}, {2, 13, 9}, {1, 12, 9}, {0, 11, 9}, {3, 13, 9}, {2, 12, 9}, {1, 11, 9},
    303. 

  303.         {0, 10, 9}, {3, 12, 8}, {2, 11, 8}, {1, 10, 8}, {0, 9, 8}, {3, 11, 8}, {2, 10, 8}, {1, 9, 8},
    304. 

  304.         {0, 8, 8}, {0, 7, 7}, {0, 6, 7}, {2, 9, 7}, {0, 5, 7}, {3, 10, 7}, {2, 8, 7}, {1, 8, 7},
    305. 

  305.         {0, 4, 7}, {0, 3, 6}, {2, 7, 6}, {1, 7, 6}, {0, 2, 6}, {3, 9, 6}, {2, 6, 6}, {1, 6, 6},
    306. 

  306.         {0, 1, 6}, {1, 5, 5}, {2, 5, 5}, {1, 4, 5}, {2, 4, 5}, {1, 3, 5}, {3, 8, 5}, {2, 3, 5},
    307. 

  307.         {1, 2, 5}, {3, 7, 4}, {3, 6, 4}, {3, 5, 4}, {3, 4, 4}, {3, 3, 4}, {2, 2, 4}, {1, 1, 4},
    308. 

  308.         {0, 0, 4}
    309. 

  309.     };
    310. 

  310. #endif
    311. 

  311.     uint code;
    312. 

  312. 

  313. #ifdef PV_NO_CLZ
    314. 

  314.     uint8 *pcode;
    315. 

  315.     if (nC < 2)
    316. 

  316.     {
    317. 

  317.         BitstreamShowBits(stream, 16, &code);
    318. 

  318. 

  319.         if (code >= 8192)
    320. 

  320.         {
    321. 

  321.             pcode = (uint8*) & (TotCofNTrail1[(code>>13)+65+2][0]);
    322. 

  322.         }
    323. 

  323.         else if (code >= 2048)
    324. 

  324.         {
    325. 

  325.             pcode = (uint8*) & (TotCofNTrail1[(code>>9)+50+2][0]);
    326. 

  326.         }
    327. 

  327.         else if (code >= 1024)
    328. 

  328.         {
    329. 

  329.             pcode = (uint8*) & (TotCofNTrail1[(code>>8)+46+2][0]);
    330. 

  330.         }
    331. 

  331.         else if (code >= 512)
    332. 

  332.         {
    333. 

  333.             pcode = (uint8*) & (TotCofNTrail1[(code>>7)+42+2][0]);
    334. 

  334.         }
    335. 

  335.         else if (code >= 256)
    336. 

  336.         {
    337. 

  337.             pcode = (uint8*) & (TotCofNTrail1[(code>>6)+38+2][0]);
    338. 

  338.         }
    339. 

  339.         else if (code >= 128)
    340. 

  340.         {
    341. 

  341.             pcode = (uint8*) & (TotCofNTrail1[(code>>5)+34+2][0]);
    342. 

  342.         }
    343. 

  343.         else if (code >= 64)
    344. 

  344.         {
    345. 

  345.             pcode = (uint8*) & (TotCofNTrail1[(code>>3)+22+2][0]);
    346. 

  346.         }
    347. 

  347.         else if (code >= 32)
    348. 

  348.         {
    349. 

  349.             pcode = (uint8*) & (TotCofNTrail1[(code>>2)+14+2][0]);
    350. 

  350.         }
    351. 

  351.         else if (code >= 16)
    352. 

  352.         {
    353. 

  353.             pcode = (uint8*) & (TotCofNTrail1[(code>>1)+6+2][0]);
    354. 

  354.         }
    355. 

  355.         else
    356. 

  356.         {
    357. 

  357.             pcode = (uint8*) & (TotCofNTrail1[(code-2)+2][0]);
    358. 

  358.         }
    359. 

  359. 

  360.         *TrailingOnes = pcode[0];
    361. 

  361.         *TotalCoeff = pcode[1];
    362. 

  362. 

  363.         BitstreamFlushBits(stream, pcode[2]);
    364. 

  364.     }
    365. 

  365.     else if (nC < 4)
    366. 

  366.     {
    367. 

  367.         BitstreamShowBits(stream, 14, &code);
    368. 

  368. 

  369.         if (code >= 4096)
    370. 

  370.         {
    371. 

  371.             pcode = (uint8*) & (TotCofNTrail2[(code>>10)+66+2][0]);
    372. 

  372.         }
    373. 

  373.         else if (code >= 2048)
    374. 

  374.         {
    375. 

  375.             pcode = (uint8*) & (TotCofNTrail2[(code>>8)+54+2][0]);
    376. 

  376.         }
    377. 

  377.         else if (code >= 512)
    378. 

  378.         {
    379. 

  379.             pcode = (uint8*) & (TotCofNTrail2[(code>>7)+46+2][0]);
    380. 

  380.         }
    381. 

  381.         else if (code >= 128)
    382. 

  382.         {
    383. 

  383.             pcode = (uint8*) & (TotCofNTrail2[(code>>5)+34+2][0]);
    384. 

  384.         }
    385. 

  385.         else if (code >= 64)
    386. 

  386.         {
    387. 

  387.             pcode = (uint8*) & (TotCofNTrail2[(code>>3)+22+2][0]);
    388. 

  388.         }
    389. 

  389.         else if (code >= 32)
    390. 

  390.         {
    391. 

  391.             pcode = (uint8*) & (TotCofNTrail2[(code>>2)+14+2][0]);
    392. 

  392.         }
    393. 

  393.         else if (code >= 16)
    394. 

  394.         {
    395. 

  395.             pcode = (uint8*) & (TotCofNTrail2[(code>>1)+6+2][0]);
    396. 

  396.         }
    397. 

  397.         else
    398. 

  398.         {
    399. 

  399.             pcode = (uint8*) & (TotCofNTrail2[code-2+2][0]);
    400. 

  400.         }
    401. 

  401.         *TrailingOnes = pcode[0];
    402. 

  402.         *TotalCoeff = pcode[1];
    403. 

  403. 

  404.         BitstreamFlushBits(stream, pcode[2]);
    405. 

  405.     }
    406. 

  406.     else if (nC < 8)
    407. 

  407.     {
    408. 

  408.         BitstreamShowBits(stream, 10, &code);
    409. 

  409. 

  410.         if (code >= 512)
    411. 

  411.         {
    412. 

  412.             pcode = (uint8*) & (TotCofNTrail3[(code>>6)+47+1][0]);
    413. 

  413.         }
    414. 

  414.         else if (code >= 256)
    415. 

  415.         {
    416. 

  416.             pcode = (uint8*) & (TotCofNTrail3[(code>>5)+39+1][0]);
    417. 

  417.         }
    418. 

  418.         else if (code >= 128)
    419. 

  419.         {
    420. 

  420.             pcode = (uint8*) & (TotCofNTrail3[(code>>4)+31+1][0]);
    421. 

  421.         }
    422. 

  422.         else if (code >= 64)
    423. 

  423.         {
    424. 

  424.             pcode = (uint8*) & (TotCofNTrail3[(code>>3)+23+1][0]);
    425. 

  425.         }
    426. 

  426.         else if (code >= 32)
    427. 

  427.         {
    428. 

  428.             pcode = (uint8*) & (TotCofNTrail3[(code>>2)+15+1][0]);
    429. 

  429.         }
    430. 

  430.         else if (code >= 16)
    431. 

  431.         {
    432. 

  432.             pcode = (uint8*) & (TotCofNTrail3[(code>>1)+7+1][0]);
    433. 

  433.         }
    434. 

  434.         else
    435. 

  435.         {
    436. 

  436.             pcode = (uint8*) & (TotCofNTrail3[code-1+1][0]);
    437. 

  437.         }
    438. 

  438.         *TrailingOnes = pcode[0];
    439. 

  439.         *TotalCoeff = pcode[1];
    440. 

  440. 

  441.         BitstreamFlushBits(stream, pcode[2]);
    442. 

  442.     }
    443. 

  443.     else
    444. 

  444.     {
    445. 

  445.         /* read 6 bit FLC */
    446. 

  446.         BitstreamReadBits(stream, 6, &code);
    447. 

  447. 

  448. 

  449.         *TrailingOnes = code & 3;
    450. 

  450.         *TotalCoeff = (code >> 2) + 1;
    451. 

  451. 

  452.         if (*TotalCoeff > 16)
    453. 

  453.         {
    454. 

  454.             *TotalCoeff = 16;  // _ERROR
    455. 

  455.         }
    456. 

  456. 

  457.         if (code == 3)
    458. 

  458.         {
    459. 

  459.             *TrailingOnes = 0;
    460. 

  460.             (*TotalCoeff)--;
    461. 

  461.         }
    462. 

  462.     }
    463. 

  463. #else
    464. 

  464.     const VLCNumCoeffTrail *ptr;
    465. 

  465.     const ShiftOffset *ptr_indx;
    466. 

  466.     uint temp, leading_zeros = 0;
    467. 

  467. 

  468.     if (nC < 8)
    469. 

  469.     {
    470. 

  470. 

  471.         BitstreamShowBits(stream, 16, &code);
    472. 

  472.         temp = code | 1;
    473. 

  473. 

  474.         PV_CLZ(leading_zeros, temp)
    475. 

  475. 

  476.         temp = nC_table[nC];
    477. 

  477.         ptr_indx = &NumCoeffTrailOnes_indx[temp][leading_zeros];
    478. 

  478.         ptr = &NumCoeffTrailOnes[temp][(code >> ptr_indx->shift) + ptr_indx->offset];
    479. 

  479.         *TrailingOnes = ptr->trailing;
    480. 

  480.         *TotalCoeff = ptr->total_coeff;
    481. 

  481.         BitstreamFlushBits(stream, ptr->length);
    482. 

  482.     }
    483. 

  483.     else
    484. 

  484.     {
    485. 

  485.         /* read 6 bit FLC */
    486. 

  486.         BitstreamReadBits(stream, 6, &code);
    487. 

  487. 

  488. 

  489.         *TrailingOnes = code & 3;
    490. 

  490.         *TotalCoeff = (code >> 2) + 1;
    491. 

  491. 

  492.         if (*TotalCoeff > 16)
    493. 

  493.         {
    494. 

  494.             *TotalCoeff = 16;  // _ERROR
    495. 

  495.         }
    496. 

  496. 

  497.         if (code == 3)
    498. 

  498.         {
    499. 

  499.             *TrailingOnes = 0;
    500. 

  500.             (*TotalCoeff)--;
    501. 

  501.         }
    502. 

  502.     }
    503. 

  503. #endif
    504. 

  504.     return AVCDEC_SUCCESS;
    505. 

  505. }
    506. 

  506. 

  507. /* TO BE OPTIMIZED !!!!! */
    508. 

  508. AVCDec_Status ce_TotalCoeffTrailingOnesChromaDC(AVCDecBitstream *stream, int *TrailingOnes, int *TotalCoeff)
    509. 

  509. {
    510. 

  510.     AVCDec_Status status;
    511. 

  511. 

  512.     const static uint8 TotCofNTrail5[21][3] =
    513. 

  513.     {
    514. 

  514.         {3, 4, 7}, {3, 4, 7}, {2, 4, 8}, {1, 4, 8}, {2, 3, 7}, {2, 3, 7}, {1, 3, 7},
    515. 

  515.         {1, 3, 7}, {0, 4, 6}, {0, 3, 6}, {0, 2, 6}, {3, 3, 6}, {1, 2, 6}, {0, 1, 6},
    516. 

  516.         {2, 2, 3}, {0, 0, 2}, {0, 0, 2}, {1, 1, 1}, {1, 1, 1}, {1, 1, 1}, {1, 1, 1}
    517. 

  517.     };
    518. 

  518. 

  519.     uint code;
    520. 

  520.     uint8 *pcode;
    521. 

  521. 

  522.     status = BitstreamShowBits(stream, 8, &code);
    523. 

  523. 

  524.     if (code >= 32)
    525. 

  525.     {
    526. 

  526.         pcode = (uint8*) & (TotCofNTrail5[(code>>5)+13][0]);
    527. 

  527.     }
    528. 

  528.     else if (code >= 8)
    529. 

  529.     {
    530. 

  530.         pcode = (uint8*) & (TotCofNTrail5[(code>>2)+6][0]);
    531. 

  531.     }
    532. 

  532.     else
    533. 

  533.     {
    534. 

  534.         pcode = (uint8*) & (TotCofNTrail5[code][0]);
    535. 

  535.     }
    536. 

  536. 

  537.     *TrailingOnes = pcode[0];
    538. 

  538.     *TotalCoeff = pcode[1];
    539. 

  539. 

  540.     BitstreamFlushBits(stream, pcode[2]);
    541. 

  541. 

  542.     return status;
    543. 

  543. }
    544. 

  544. 

  545. /* see Table 9-6 */
    546. 

  546. AVCDec_Status ce_LevelPrefix(AVCDecBitstream *stream, uint *code)
    547. 

  547. {
    548. 

  548.     uint temp;
    549. 

  549.     uint leading_zeros = 0;
    550. 

  550.     BitstreamShowBits(stream, 16, &temp);
    551. 

  551.     temp |= 1 ;
    552. 

  552. 

  553.     PV_CLZ(leading_zeros, temp)
    554. 

  554. 

  555.     BitstreamFlushBits(stream, leading_zeros + 1);
    556. 

  556.     *code = leading_zeros;
    557. 

  557.     return AVCDEC_SUCCESS;
    558. 

  558. }
    559. 

  559. 

  560. /* see Table 9-7 and 9-8 */
    561. 

  561. AVCDec_Status ce_TotalZeros(AVCDecBitstream *stream, int *code, int TotalCoeff)
    562. 

  562. {
    563. 

  563.     const static uint8 TotZero1[28][2] = {{15, 9}, {14, 9}, {13, 9}, {12, 8},
    564. 

  564.         {12, 8}, {11, 8}, {11, 8}, {10, 7}, {9, 7}, {8, 6}, {8, 6}, {7, 6}, {7, 6}, {6, 5}, {6, 5},
    565. 

  565.         {6, 5}, {6, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}, {4, 4}, {3, 4},
    566. 

  566.         {2, 3}, {2, 3}, {1, 3}, {1, 3}, {0, 1}
    567. 

  567.     };
    568. 

  568. 

  569.     const static uint8 TotZero2n3[2][18][2] = {{{14, 6}, {13, 6}, {12, 6}, {11, 6},
    570. 

  570.             {10, 5}, {10, 5}, {9, 5}, {9, 5}, {8, 4}, {7, 4}, {6, 4}, {5, 4}, {4, 3}, {4, 3},
    571. 

  571.             {3, 3}, {2, 3}, {1, 3}, {0, 3}},
    572. 

  572. 

  573.         /*const static uint8 TotZero3[18][2]=*/{{13, 6}, {11, 6}, {12, 5}, {12, 5}, {10, 5},
    574. 

  574.             {10, 5}, {9, 5}, {9, 5}, {8, 4}, {5, 4}, {4, 4}, {0, 4}, {7, 3}, {7, 3}, {6, 3}, {3, 3},
    575. 

  575.             {2, 3}, {1, 3}}
    576. 

  576.     };
    577. 

  577. 

  578.     const static uint8 TotZero4[17][2] = {{12, 5}, {11, 5}, {10, 5}, {0, 5}, {9, 4},
    579. 

  579.         {9, 4}, {7, 4}, {7, 4}, {3, 4}, {3, 4}, {2, 4}, {2, 4}, {8, 3}, {6, 3}, {5, 3}, {4, 3}, {1, 3}
    580. 

  580.     };
    581. 

  581. 

  582.     const static uint8 TotZero5[13][2] = {{11, 5}, {9, 5}, {10, 4}, {8, 4}, {2, 4},
    583. 

  583.         {1, 4}, {0, 4}, {7, 3}, {7, 3}, {6, 3}, {5, 3}, {4, 3}, {3, 3}
    584. 

  584.     };
    585. 

  585. 

  586.     const static uint8 TotZero6to10[5][15][2] = {{{10, 6}, {0, 6}, {1, 5}, {1, 5}, {8, 4},
    587. 

  587.             {8, 4}, {8, 4}, {8, 4}, {9, 3}, {7, 3}, {6, 3}, {5, 3}, {4, 3}, {3, 3}, {2, 3}},
    588. 

  588. 

  589.         /*const static uint8 TotZero7[15][2]=*/{{9, 6}, {0, 6}, {1, 5}, {1, 5}, {7, 4},
    590. 

  590.             {7, 4}, {7, 4}, {7, 4}, {8, 3}, {6, 3}, {4, 3}, {3, 3}, {2, 3}, {5, 2}, {5, 2}},
    591. 

  591. 

  592.         /*const static uint8 TotZero8[15][2]=*/{{8, 6}, {0, 6}, {2, 5}, {2, 5}, {1, 4},
    593. 

  593.             {1, 4}, {1, 4}, {1, 4}, {7, 3}, {6, 3}, {3, 3}, {5, 2}, {5, 2}, {4, 2}, {4, 2}},
    594. 

  594. 

  595.         /*const static uint8 TotZero9[15][2]=*/{{1, 6}, {0, 6}, {7, 5}, {7, 5}, {2, 4},
    596. 

  596.             {2, 4}, {2, 4}, {2, 4}, {5, 3}, {6, 2}, {6, 2}, {4, 2}, {4, 2}, {3, 2}, {3, 2}},
    597. 

  597. 

  598.         /*const static uint8 TotZero10[11][2]=*/{{1, 5}, {0, 5}, {6, 4}, {6, 4}, {2, 3},
    599. 

  599.             {2, 3}, {2, 3}, {2, 3}, {5, 2}, {4, 2}, {3, 2}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}
    600. 

  600.     };
    601. 

  601. 

  602.     const static uint8 TotZero11[7][2] = {{0, 4}, {1, 4}, {2, 3}, {2, 3}, {3, 3}, {5, 3}, {4, 1}};
    603. 

  603. 

  604.     const static uint8 TotZero12to15[4][5][2] =
    605. 

  605.     {
    606. 

  606.         {{3, 1}, {2, 2}, {4, 3}, {1, 4}, {0, 4}},
    607. 

  607.         {{2, 1}, {3, 2}, {1, 3}, {0, 3}, {0, 0}},
    608. 

  608.         {{2, 1}, {1, 2}, {0, 2}, {0, 0}, {0, 0}},
    609. 

  609.         {{1, 1}, {0, 1}, {0, 0}, {0, 0}, {0, 0}}
    610. 

  610.     };
    611. 

  611. 

  612.     uint temp, mask;
    613. 

  613.     int indx;
    614. 

  614.     uint8 *pcode;
    615. 

  615. 

  616.     if (TotalCoeff == 1)
    617. 

  617.     {
    618. 

  618.         BitstreamShowBits(stream, 9, &temp);
    619. 

  619. 

  620.         if (temp >= 256)
    621. 

  621.         {
    622. 

  622.             pcode = (uint8*) & (TotZero1[27][0]);
    623. 

  623.         }
    624. 

  624.         else if (temp >= 64)
    625. 

  625.         {
    626. 

  626.             pcode = (uint8*) & (TotZero1[(temp>>5)+19][0]);
    627. 

  627.         }
    628. 

  628.         else if (temp >= 8)
    629. 

  629.         {
    630. 

  630.             pcode = (uint8*) & (TotZero1[(temp>>2)+5][0]);
    631. 

  631.         }
    632. 

  632.         else
    633. 

  633.         {
    634. 

  634.             pcode = (uint8*) & (TotZero1[temp-1][0]);
    635. 

  635.         }
    636. 

  636. 

  637.     }
    638. 

  638.     else if (TotalCoeff == 2 || TotalCoeff == 3)
    639. 

  639.     {
    640. 

  640.         BitstreamShowBits(stream, 6, &temp);
    641. 

  641. 

  642.         if (temp >= 32)
    643. 

  643.         {
    644. 

  644.             pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][(temp>>3)+10][0]);
    645. 

  645.         }
    646. 

  646.         else if (temp >= 8)
    647. 

  647.         {
    648. 

  648.             pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][(temp>>2)+6][0]);
    649. 

  649.         }
    650. 

  650.         else
    651. 

  651.         {
    652. 

  652.             pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][temp][0]);
    653. 

  653.         }
    654. 

  654.     }
    655. 

  655.     else if (TotalCoeff == 4)
    656. 

  656.     {
    657. 

  657.         BitstreamShowBits(stream, 5, &temp);
    658. 

  658. 

  659.         if (temp >= 12)
    660. 

  660.         {
    661. 

  661.             pcode = (uint8*) & (TotZero4[(temp>>2)+9][0]);
    662. 

  662.         }
    663. 

  663.         else
    664. 

  664.         {
    665. 

  665.             pcode = (uint8*) & (TotZero4[temp][0]);
    666. 

  666.         }
    667. 

  667.     }
    668. 

  668.     else if (TotalCoeff == 5)
    669. 

  669.     {
    670. 

  670.         BitstreamShowBits(stream, 5, &temp);
    671. 

  671. 

  672.         if (temp >= 16)
    673. 

  673.         {
    674. 

  674.             pcode = (uint8*) & (TotZero5[(temp>>2)+5][0]);
    675. 

  675.         }
    676. 

  676.         else if (temp >= 2)
    677. 

  677.         {
    678. 

  678.             pcode = (uint8*) & (TotZero5[(temp>>1)+1][0]);
    679. 

  679.         }
    680. 

  680.         else
    681. 

  681.         {
    682. 

  682.             pcode = (uint8*) & (TotZero5[temp][0]);
    683. 

  683.         }
    684. 

  684.     }
    685. 

  685.     else if (TotalCoeff >= 6 && TotalCoeff <= 10)
    686. 

  686.     {
    687. 

  687.         if (TotalCoeff == 10)
    688. 

  688.         {
    689. 

  689.             BitstreamShowBits(stream, 5, &temp);
    690. 

  690.         }
    691. 

  691.         else
    692. 

  692.         {
    693. 

  693.             BitstreamShowBits(stream, 6, &temp);
    694. 

  694.         }
    695. 

  695. 

  696. 

  697.         if (temp >= 8)
    698. 

  698.         {
    699. 

  699.             pcode = (uint8*) & (TotZero6to10[TotalCoeff-6][(temp>>3)+7][0]);
    700. 

  700.         }
    701. 

  701.         else
    702. 

  702.         {
    703. 

  703.             pcode = (uint8*) & (TotZero6to10[TotalCoeff-6][temp][0]);
    704. 

  704.         }
    705. 

  705.     }
    706. 

  706.     else if (TotalCoeff == 11)
    707. 

  707.     {
    708. 

  708.         BitstreamShowBits(stream, 4, &temp);
    709. 

  709. 

  710. 

  711.         if (temp >= 8)
    712. 

  712.         {
    713. 

  713.             pcode = (uint8*) & (TotZero11[6][0]);
    714. 

  714.         }
    715. 

  715.         else if (temp >= 4)
    716. 

  716.         {
    717. 

  717.             pcode = (uint8*) & (TotZero11[(temp>>1)+2][0]);
    718. 

  718.         }
    719. 

  719.         else
    720. 

  720.         {
    721. 

  721.             pcode = (uint8*) & (TotZero11[temp][0]);
    722. 

  722.         }
    723. 

  723.     }
    724. 

  724.     else
    725. 

  725.     {
    726. 

  726.         BitstreamShowBits(stream, (16 - TotalCoeff), &temp);
    727. 

  727.         mask = 1 << (15 - TotalCoeff);
    728. 

  728.         indx = 0;
    729. 

  729.         while ((temp&mask) == 0 && indx < (16 - TotalCoeff)) /* search location of 1 bit */
    730. 

  730.         {
    731. 

  731.             mask >>= 1;
    732. 

  732.             indx++;
    733. 

  733.         }
    734. 

  734. 

  735.         pcode = (uint8*) & (TotZero12to15[TotalCoeff-12][indx]);
    736. 

  736.     }
    737. 

  737. 

  738.     *code = pcode[0];
    739. 

  739.     BitstreamFlushBits(stream, pcode[1]);
    740. 

  740. 

  741.     return AVCDEC_SUCCESS;
    742. 

  742. }
    743. 

  743. 

  744. /* see Table 9-9 */
    745. 

  745. AVCDec_Status ce_TotalZerosChromaDC(AVCDecBitstream *stream, int *code, int TotalCoeff)
    746. 

  746. {
    747. 

  747.     const static uint8 TotZeroChrom1to3[3][8][2] =
    748. 

  748.     {
    749. 

  749.         {{3, 3}, {2, 3}, {1, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 1}, {0, 1}},
    750. 

  750.         {{2, 2}, {2, 2}, {1, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 1}, {0, 1}},
    751. 

  751.         {{1, 1}, {1, 1}, {1, 1}, {1, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}},
    752. 

  752.     };
    753. 

  753. 

  754. 

  755.     uint temp;
    756. 

  756.     uint8 *pcode;
    757. 

  757. 

  758.     BitstreamShowBits(stream, 3, &temp);
    759. 

  759.     pcode = (uint8*) & (TotZeroChrom1to3[TotalCoeff-1][temp]);
    760. 

  760. 

  761.     *code = pcode[0];
    762. 

  762. 

  763.     BitstreamFlushBits(stream, pcode[1]);
    764. 

  764. 

  765.     return AVCDEC_SUCCESS;
    766. 

  766. }
    767. 

  767. 

  768. /* see Table 9-10 */
    769. 

  769. AVCDec_Status ce_RunBefore(AVCDecBitstream *stream, int *code, int zerosLeft)
    770. 

  770. {
    771. 

  771.     const static int codlen[6] = {1, 2, 2, 3, 3, 3}; /* num bits to read */
    772. 

  772.     const static uint8 RunBeforeTab[6][8][2] = {{{1, 1}, {0, 1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
    773. 

  773.         /*const static int RunBefore2[4][2]=*/{{2, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
    774. 

  774.         /*const static int RunBefore3[4][2]=*/{{3, 2}, {2, 2}, {1, 2}, {0, 2}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
    775. 

  775.         /*const static int RunBefore4[7][2]=*/{{4, 3}, {3, 3}, {2, 2}, {2, 2}, {1, 2}, {1, 2}, {0, 2}, {0, 2}},
    776. 

  776.         /*const static int RunBefore5[7][2]=*/{{5, 3}, {4, 3}, {3, 3}, {2, 3}, {1, 2}, {1, 2}, {0, 2}, {0, 2}},
    777. 

  777.         /*const static int RunBefore6[7][2]=*/{{1, 3}, {2, 3}, {4, 3}, {3, 3}, {6, 3}, {5, 3}, {0, 2}, {0, 2}}
    778. 

  778.     };
    779. 

  779. 

  780.     uint temp;
    781. 

  781.     uint8 *pcode;
    782. 

  782.     int indx;
    783. 

  783. 

  784.     if (zerosLeft <= 6)
    785. 

  785.     {
    786. 

  786.         BitstreamShowBits(stream, codlen[zerosLeft-1], &temp);
    787. 

  787. 

  788.         pcode = (uint8*) & (RunBeforeTab[zerosLeft-1][temp][0]);
    789. 

  789. 

  790.         *code = pcode[0];
    791. 

  791. 

  792.         BitstreamFlushBits(stream, pcode[1]);
    793. 

  793.     }
    794. 

  794.     else
    795. 

  795.     {
    796. 

  796.         BitstreamReadBits(stream, 3, &temp);
    797. 

  797.         if (temp)
    798. 

  798.         {
    799. 

  799.             *code = 7 - temp;
    800. 

  800.         }
    801. 

  801.         else
    802. 

  802.         {
    803. 

  803.             BitstreamShowBits(stream, 9, &temp);
    804. 

  804.             temp <<= 7;
    805. 

  805.             temp |= 1;
    806. 

  806.             indx = 0;
    807. 

  807.             PV_CLZ(indx, temp)
    808. 

  808.             *code = 7 + indx;
    809. 

  809.             BitstreamFlushBits(stream, indx + 1);
    810. 

  810.         }
    811. 

  811.     }
    812. 

  812. 

  813. 

  814.     return AVCDEC_SUCCESS;
    815. 

  815. }
    816. 

  816.