1 /* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18 #include "avcdec_lib.h" 19 #include "avcdec_bitstream.h" 20 21 //#define PV_ARM_V5 22 #ifdef PV_ARM_V5 23 #define PV_CLZ(A,B) __asm{CLZ (A),(B)} \ 24 A -= 16; 25 #else 26 #define PV_CLZ(A,B) while (((B) & 0x8000) == 0) {(B) <<=1; A++;} 27 #endif 28 29 30 #define PV_NO_CLZ 31 32 #ifndef PV_NO_CLZ 33 typedef struct tagVLCNumCoeffTrail 34 { 35 int trailing; 36 int total_coeff; 37 int length; 38 } VLCNumCoeffTrail; 39 40 typedef struct tagShiftOffset 41 { 42 int shift; 43 int offset; 44 } ShiftOffset; 45 46 const VLCNumCoeffTrail NumCoeffTrailOnes[3][67] = 47 { 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 {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 {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 {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 {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 {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 {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 {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 { -1, -1, -1}, { -1, -1, -1}, { -1, -1, -1}}, 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 {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 {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 {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 {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 {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 {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 {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 {1, 16, 14}, {0, 16, 14}, {3, 15, 13}}, 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 {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 {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 {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 {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 {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 {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 {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 { -1, -1, -1}, { -1, -1, -1}, { -1, -1, -1}} 77 }; 78 79 80 const ShiftOffset NumCoeffTrailOnes_indx[3][15] = 81 { 82 {{15, -1}, {14, 0}, {13, 1}, {10, -1}, {9, 3}, {8, 7}, {7, 11}, {6, 15}, 83 {5, 19}, {3, 19}, {2, 27}, {1, 35}, {0, 43}, {0, 55}, {1, 62}}, 84 85 {{14, -2}, {12, -2}, {10, -2}, {10, 10}, {9, 14}, {8, 18}, {7, 22}, {5, 22}, 86 {4, 30}, {3, 38}, {2, 46}, {2, 58}, {3, 65}, {16, 0}, {16, 0}}, 87 88 {{12, -8}, {11, 0}, {10, 8}, {9, 16}, {8, 24}, {7, 32}, {6, 40}, {6, 52}, 89 {6, 58}, {6, 61}, {16, 0}, {16, 0}, {16, 0}, {16, 0}, {16, 0}} 90 }; 91 92 const static int nC_table[8] = {0, 0, 1, 1, 2, 2, 2, 2}; 93 94 #endif 95 /** 96 See algorithm in subclause 9.1, Table 9-1, Table 9-2. */ 97 AVCDec_Status ue_v(AVCDecBitstream *bitstream, uint *codeNum) 98 { 99 uint temp, tmp_cnt; 100 int leading_zeros = 0; 101 BitstreamShowBits(bitstream, 16, &temp); 102 tmp_cnt = temp | 0x1; 103 104 PV_CLZ(leading_zeros, tmp_cnt) 105 106 if (leading_zeros < 8) 107 { 108 *codeNum = (temp >> (15 - (leading_zeros << 1))) - 1; 109 BitstreamFlushBits(bitstream, (leading_zeros << 1) + 1); 110 } 111 else 112 { 113 BitstreamReadBits(bitstream, (leading_zeros << 1) + 1, &temp); 114 *codeNum = temp - 1; 115 } 116 117 return AVCDEC_SUCCESS; 118 } 119 120 /** 121 See subclause 9.1.1, Table 9-3 */ 122 AVCDec_Status se_v(AVCDecBitstream *bitstream, int *value) 123 { 124 uint temp, tmp_cnt; 125 int leading_zeros = 0; 126 BitstreamShowBits(bitstream, 16, &temp); 127 tmp_cnt = temp | 0x1; 128 129 PV_CLZ(leading_zeros, tmp_cnt) 130 131 if (leading_zeros < 8) 132 { 133 temp >>= (15 - (leading_zeros << 1)); 134 BitstreamFlushBits(bitstream, (leading_zeros << 1) + 1); 135 } 136 else 137 { 138 BitstreamReadBits(bitstream, (leading_zeros << 1) + 1, &temp); 139 } 140 141 *value = temp >> 1; 142 143 if (temp & 0x01) // lsb is signed bit 144 *value = -(*value); 145 146 // leading_zeros = temp >> 1; 147 // *value = leading_zeros - (leading_zeros*2*(temp&1)); 148 149 return AVCDEC_SUCCESS; 150 } 151 152 AVCDec_Status se_v32bit(AVCDecBitstream *bitstream, int32 *value) 153 { 154 int leadingZeros; 155 uint32 infobits; 156 uint32 codeNum; 157 158 if (AVCDEC_SUCCESS != GetEGBitstring32bit(bitstream, &leadingZeros, &infobits)) 159 return AVCDEC_FAIL; 160 161 codeNum = (1 << leadingZeros) - 1 + infobits; 162 163 *value = (codeNum + 1) / 2; 164 165 if ((codeNum & 0x01) == 0) // lsb is signed bit 166 *value = -(*value); 167 168 return AVCDEC_SUCCESS; 169 } 170 171 172 AVCDec_Status te_v(AVCDecBitstream *bitstream, uint *value, uint range) 173 { 174 if (range > 1) 175 { 176 ue_v(bitstream, value); 177 } 178 else 179 { 180 BitstreamRead1Bit(bitstream, value); 181 *value = 1 - (*value); 182 } 183 return AVCDEC_SUCCESS; 184 } 185 186 187 188 /* This function is only used for syntax with range from -2^31 to 2^31-1 */ 189 /* only a few of them in the SPS and PPS */ 190 AVCDec_Status GetEGBitstring32bit(AVCDecBitstream *bitstream, int *leadingZeros, uint32 *infobits) 191 { 192 int bit_value; 193 uint info_temp; 194 195 *leadingZeros = 0; 196 197 BitstreamRead1Bit(bitstream, (uint*)&bit_value); 198 199 while (!bit_value) 200 { 201 (*leadingZeros)++; 202 BitstreamRead1Bit(bitstream, (uint*)&bit_value); 203 } 204 205 if (*leadingZeros > 0) 206 { 207 if (sizeof(uint) == 4) /* 32 bit machine */ 208 { 209 BitstreamReadBits(bitstream, *leadingZeros, (uint*)&info_temp); 210 *infobits = (uint32)info_temp; 211 } 212 else if (sizeof(uint) == 2) /* 16 bit machine */ 213 { 214 *infobits = 0; 215 if (*leadingZeros > 16) 216 { 217 BitstreamReadBits(bitstream, 16, (uint*)&info_temp); 218 (*leadingZeros) -= 16; 219 *infobits = ((uint32)info_temp) << (*leadingZeros); 220 } 221 222 BitstreamReadBits(bitstream, *leadingZeros, (uint*)&info_temp); 223 *infobits |= (uint32)info_temp ; 224 } 225 } 226 else 227 *infobits = 0; 228 229 return AVCDEC_SUCCESS; 230 } 231 232 /* see Table 9-4 assignment of codeNum to values of coded_block_pattern. */ 233 const static uint8 MapCBP[48][2] = 234 { 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 {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 {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 {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 }; 240 241 AVCDec_Status DecodeCBP(AVCMacroblock *currMB, AVCDecBitstream *stream) 242 { 243 uint codeNum; 244 uint coded_block_pattern; 245 246 ue_v(stream, &codeNum); 247 248 if (codeNum > 47) 249 { 250 return AVCDEC_FAIL; 251 } 252 253 /* can get rid of the if _OPTIMIZE */ 254 if (currMB->mbMode == AVC_I4) 255 { 256 coded_block_pattern = MapCBP[codeNum][0]; 257 } 258 else 259 { 260 coded_block_pattern = MapCBP[codeNum][1]; 261 } 262 263 // currMB->cbpL = coded_block_pattern&0xF; /* modulo 16 */ 264 // currMB->cbpC = coded_block_pattern>>4; /* divide 16 */ 265 currMB->CBP = coded_block_pattern; 266 267 return AVCDEC_SUCCESS; 268 } 269 270 271 /* TO BE OPTIMIZED !!!!! */ 272 AVCDec_Status ce_TotalCoeffTrailingOnes(AVCDecBitstream *stream, int *TrailingOnes, int *TotalCoeff, int nC) 273 { 274 #ifdef PV_NO_CLZ 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 {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 {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 {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 {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 {3, 9, 11}, {2, 7, 11}, {1, 6, 11}, {0, 5, 11}, {3, 8, 10}, 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 {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 {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 {1, 1, 2}, {1, 1, 2}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1} 285 }; 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 {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 {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 {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 {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 {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 {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 {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 {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 {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 {0, 0, 2}, {0, 0, 2}, {0, 0, 2}, {0, 0, 2} 298 }; 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 {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 {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 {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 {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 {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 {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 {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 {0, 0, 4} 309 }; 310 #endif 311 uint code; 312 313 #ifdef PV_NO_CLZ 314 uint8 *pcode; 315 if (nC < 2) 316 { 317 BitstreamShowBits(stream, 16, &code); 318 319 if (code >= 8192) 320 { 321 pcode = (uint8*) & (TotCofNTrail1[(code>>13)+65+2][0]); 322 } 323 else if (code >= 2048) 324 { 325 pcode = (uint8*) & (TotCofNTrail1[(code>>9)+50+2][0]); 326 } 327 else if (code >= 1024) 328 { 329 pcode = (uint8*) & (TotCofNTrail1[(code>>8)+46+2][0]); 330 } 331 else if (code >= 512) 332 { 333 pcode = (uint8*) & (TotCofNTrail1[(code>>7)+42+2][0]); 334 } 335 else if (code >= 256) 336 { 337 pcode = (uint8*) & (TotCofNTrail1[(code>>6)+38+2][0]); 338 } 339 else if (code >= 128) 340 { 341 pcode = (uint8*) & (TotCofNTrail1[(code>>5)+34+2][0]); 342 } 343 else if (code >= 64) 344 { 345 pcode = (uint8*) & (TotCofNTrail1[(code>>3)+22+2][0]); 346 } 347 else if (code >= 32) 348 { 349 pcode = (uint8*) & (TotCofNTrail1[(code>>2)+14+2][0]); 350 } 351 else if (code >= 16) 352 { 353 pcode = (uint8*) & (TotCofNTrail1[(code>>1)+6+2][0]); 354 } 355 else 356 { 357 pcode = (uint8*) & (TotCofNTrail1[(code-2)+2][0]); 358 } 359 360 *TrailingOnes = pcode[0]; 361 *TotalCoeff = pcode[1]; 362 363 BitstreamFlushBits(stream, pcode[2]); 364 } 365 else if (nC < 4) 366 { 367 BitstreamShowBits(stream, 14, &code); 368 369 if (code >= 4096) 370 { 371 pcode = (uint8*) & (TotCofNTrail2[(code>>10)+66+2][0]); 372 } 373 else if (code >= 2048) 374 { 375 pcode = (uint8*) & (TotCofNTrail2[(code>>8)+54+2][0]); 376 } 377 else if (code >= 512) 378 { 379 pcode = (uint8*) & (TotCofNTrail2[(code>>7)+46+2][0]); 380 } 381 else if (code >= 128) 382 { 383 pcode = (uint8*) & (TotCofNTrail2[(code>>5)+34+2][0]); 384 } 385 else if (code >= 64) 386 { 387 pcode = (uint8*) & (TotCofNTrail2[(code>>3)+22+2][0]); 388 } 389 else if (code >= 32) 390 { 391 pcode = (uint8*) & (TotCofNTrail2[(code>>2)+14+2][0]); 392 } 393 else if (code >= 16) 394 { 395 pcode = (uint8*) & (TotCofNTrail2[(code>>1)+6+2][0]); 396 } 397 else 398 { 399 pcode = (uint8*) & (TotCofNTrail2[code-2+2][0]); 400 } 401 *TrailingOnes = pcode[0]; 402 *TotalCoeff = pcode[1]; 403 404 BitstreamFlushBits(stream, pcode[2]); 405 } 406 else if (nC < 8) 407 { 408 BitstreamShowBits(stream, 10, &code); 409 410 if (code >= 512) 411 { 412 pcode = (uint8*) & (TotCofNTrail3[(code>>6)+47+1][0]); 413 } 414 else if (code >= 256) 415 { 416 pcode = (uint8*) & (TotCofNTrail3[(code>>5)+39+1][0]); 417 } 418 else if (code >= 128) 419 { 420 pcode = (uint8*) & (TotCofNTrail3[(code>>4)+31+1][0]); 421 } 422 else if (code >= 64) 423 { 424 pcode = (uint8*) & (TotCofNTrail3[(code>>3)+23+1][0]); 425 } 426 else if (code >= 32) 427 { 428 pcode = (uint8*) & (TotCofNTrail3[(code>>2)+15+1][0]); 429 } 430 else if (code >= 16) 431 { 432 pcode = (uint8*) & (TotCofNTrail3[(code>>1)+7+1][0]); 433 } 434 else 435 { 436 pcode = (uint8*) & (TotCofNTrail3[code-1+1][0]); 437 } 438 *TrailingOnes = pcode[0]; 439 *TotalCoeff = pcode[1]; 440 441 BitstreamFlushBits(stream, pcode[2]); 442 } 443 else 444 { 445 /* read 6 bit FLC */ 446 BitstreamReadBits(stream, 6, &code); 447 448 449 *TrailingOnes = code & 3; 450 *TotalCoeff = (code >> 2) + 1; 451 452 if (*TotalCoeff > 16) 453 { 454 *TotalCoeff = 16; // _ERROR 455 } 456 457 if (code == 3) 458 { 459 *TrailingOnes = 0; 460 (*TotalCoeff)--; 461 } 462 } 463 #else 464 const VLCNumCoeffTrail *ptr; 465 const ShiftOffset *ptr_indx; 466 uint temp, leading_zeros = 0; 467 468 if (nC < 8) 469 { 470 471 BitstreamShowBits(stream, 16, &code); 472 temp = code | 1; 473 474 PV_CLZ(leading_zeros, temp) 475 476 temp = nC_table[nC]; 477 ptr_indx = &NumCoeffTrailOnes_indx[temp][leading_zeros]; 478 ptr = &NumCoeffTrailOnes[temp][(code >> ptr_indx->shift) + ptr_indx->offset]; 479 *TrailingOnes = ptr->trailing; 480 *TotalCoeff = ptr->total_coeff; 481 BitstreamFlushBits(stream, ptr->length); 482 } 483 else 484 { 485 /* read 6 bit FLC */ 486 BitstreamReadBits(stream, 6, &code); 487 488 489 *TrailingOnes = code & 3; 490 *TotalCoeff = (code >> 2) + 1; 491 492 if (*TotalCoeff > 16) 493 { 494 *TotalCoeff = 16; // _ERROR 495 } 496 497 if (code == 3) 498 { 499 *TrailingOnes = 0; 500 (*TotalCoeff)--; 501 } 502 } 503 #endif 504 return AVCDEC_SUCCESS; 505 } 506 507 /* TO BE OPTIMIZED !!!!! */ 508 AVCDec_Status ce_TotalCoeffTrailingOnesChromaDC(AVCDecBitstream *stream, int *TrailingOnes, int *TotalCoeff) 509 { 510 AVCDec_Status status; 511 512 const static uint8 TotCofNTrail5[21][3] = 513 { 514 {3, 4, 7}, {3, 4, 7}, {2, 4, 8}, {1, 4, 8}, {2, 3, 7}, {2, 3, 7}, {1, 3, 7}, 515 {1, 3, 7}, {0, 4, 6}, {0, 3, 6}, {0, 2, 6}, {3, 3, 6}, {1, 2, 6}, {0, 1, 6}, 516 {2, 2, 3}, {0, 0, 2}, {0, 0, 2}, {1, 1, 1}, {1, 1, 1}, {1, 1, 1}, {1, 1, 1} 517 }; 518 519 uint code; 520 uint8 *pcode; 521 522 status = BitstreamShowBits(stream, 8, &code); 523 524 if (code >= 32) 525 { 526 pcode = (uint8*) & (TotCofNTrail5[(code>>5)+13][0]); 527 } 528 else if (code >= 8) 529 { 530 pcode = (uint8*) & (TotCofNTrail5[(code>>2)+6][0]); 531 } 532 else 533 { 534 pcode = (uint8*) & (TotCofNTrail5[code][0]); 535 } 536 537 *TrailingOnes = pcode[0]; 538 *TotalCoeff = pcode[1]; 539 540 BitstreamFlushBits(stream, pcode[2]); 541 542 return status; 543 } 544 545 /* see Table 9-6 */ 546 AVCDec_Status ce_LevelPrefix(AVCDecBitstream *stream, uint *code) 547 { 548 uint temp; 549 uint leading_zeros = 0; 550 BitstreamShowBits(stream, 16, &temp); 551 temp |= 1 ; 552 553 PV_CLZ(leading_zeros, temp) 554 555 BitstreamFlushBits(stream, leading_zeros + 1); 556 *code = leading_zeros; 557 return AVCDEC_SUCCESS; 558 } 559 560 /* see Table 9-7 and 9-8 */ 561 AVCDec_Status ce_TotalZeros(AVCDecBitstream *stream, int *code, int TotalCoeff) 562 { 563 const static uint8 TotZero1[28][2] = {{15, 9}, {14, 9}, {13, 9}, {12, 8}, 564 {12, 8}, {11, 8}, {11, 8}, {10, 7}, {9, 7}, {8, 6}, {8, 6}, {7, 6}, {7, 6}, {6, 5}, {6, 5}, 565 {6, 5}, {6, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}, {4, 4}, {3, 4}, 566 {2, 3}, {2, 3}, {1, 3}, {1, 3}, {0, 1} 567 }; 568 569 const static uint8 TotZero2n3[2][18][2] = {{{14, 6}, {13, 6}, {12, 6}, {11, 6}, 570 {10, 5}, {10, 5}, {9, 5}, {9, 5}, {8, 4}, {7, 4}, {6, 4}, {5, 4}, {4, 3}, {4, 3}, 571 {3, 3}, {2, 3}, {1, 3}, {0, 3}}, 572 573 /*const static uint8 TotZero3[18][2]=*/{{13, 6}, {11, 6}, {12, 5}, {12, 5}, {10, 5}, 574 {10, 5}, {9, 5}, {9, 5}, {8, 4}, {5, 4}, {4, 4}, {0, 4}, {7, 3}, {7, 3}, {6, 3}, {3, 3}, 575 {2, 3}, {1, 3}} 576 }; 577 578 const static uint8 TotZero4[17][2] = {{12, 5}, {11, 5}, {10, 5}, {0, 5}, {9, 4}, 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 }; 581 582 const static uint8 TotZero5[13][2] = {{11, 5}, {9, 5}, {10, 4}, {8, 4}, {2, 4}, 583 {1, 4}, {0, 4}, {7, 3}, {7, 3}, {6, 3}, {5, 3}, {4, 3}, {3, 3} 584 }; 585 586 const static uint8 TotZero6to10[5][15][2] = {{{10, 6}, {0, 6}, {1, 5}, {1, 5}, {8, 4}, 587 {8, 4}, {8, 4}, {8, 4}, {9, 3}, {7, 3}, {6, 3}, {5, 3}, {4, 3}, {3, 3}, {2, 3}}, 588 589 /*const static uint8 TotZero7[15][2]=*/{{9, 6}, {0, 6}, {1, 5}, {1, 5}, {7, 4}, 590 {7, 4}, {7, 4}, {7, 4}, {8, 3}, {6, 3}, {4, 3}, {3, 3}, {2, 3}, {5, 2}, {5, 2}}, 591 592 /*const static uint8 TotZero8[15][2]=*/{{8, 6}, {0, 6}, {2, 5}, {2, 5}, {1, 4}, 593 {1, 4}, {1, 4}, {1, 4}, {7, 3}, {6, 3}, {3, 3}, {5, 2}, {5, 2}, {4, 2}, {4, 2}}, 594 595 /*const static uint8 TotZero9[15][2]=*/{{1, 6}, {0, 6}, {7, 5}, {7, 5}, {2, 4}, 596 {2, 4}, {2, 4}, {2, 4}, {5, 3}, {6, 2}, {6, 2}, {4, 2}, {4, 2}, {3, 2}, {3, 2}}, 597 598 /*const static uint8 TotZero10[11][2]=*/{{1, 5}, {0, 5}, {6, 4}, {6, 4}, {2, 3}, 599 {2, 3}, {2, 3}, {2, 3}, {5, 2}, {4, 2}, {3, 2}, {0, 0}, {0, 0}, {0, 0}, {0, 0}} 600 }; 601 602 const static uint8 TotZero11[7][2] = {{0, 4}, {1, 4}, {2, 3}, {2, 3}, {3, 3}, {5, 3}, {4, 1}}; 603 604 const static uint8 TotZero12to15[4][5][2] = 605 { 606 {{3, 1}, {2, 2}, {4, 3}, {1, 4}, {0, 4}}, 607 {{2, 1}, {3, 2}, {1, 3}, {0, 3}, {0, 0}}, 608 {{2, 1}, {1, 2}, {0, 2}, {0, 0}, {0, 0}}, 609 {{1, 1}, {0, 1}, {0, 0}, {0, 0}, {0, 0}} 610 }; 611 612 uint temp, mask; 613 int indx; 614 uint8 *pcode; 615 616 if (TotalCoeff == 1) 617 { 618 BitstreamShowBits(stream, 9, &temp); 619 620 if (temp >= 256) 621 { 622 pcode = (uint8*) & (TotZero1[27][0]); 623 } 624 else if (temp >= 64) 625 { 626 pcode = (uint8*) & (TotZero1[(temp>>5)+19][0]); 627 } 628 else if (temp >= 8) 629 { 630 pcode = (uint8*) & (TotZero1[(temp>>2)+5][0]); 631 } 632 else 633 { 634 pcode = (uint8*) & (TotZero1[temp-1][0]); 635 } 636 637 } 638 else if (TotalCoeff == 2 || TotalCoeff == 3) 639 { 640 BitstreamShowBits(stream, 6, &temp); 641 642 if (temp >= 32) 643 { 644 pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][(temp>>3)+10][0]); 645 } 646 else if (temp >= 8) 647 { 648 pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][(temp>>2)+6][0]); 649 } 650 else 651 { 652 pcode = (uint8*) & (TotZero2n3[TotalCoeff-2][temp][0]); 653 } 654 } 655 else if (TotalCoeff == 4) 656 { 657 BitstreamShowBits(stream, 5, &temp); 658 659 if (temp >= 12) 660 { 661 pcode = (uint8*) & (TotZero4[(temp>>2)+9][0]); 662 } 663 else 664 { 665 pcode = (uint8*) & (TotZero4[temp][0]); 666 } 667 } 668 else if (TotalCoeff == 5) 669 { 670 BitstreamShowBits(stream, 5, &temp); 671 672 if (temp >= 16) 673 { 674 pcode = (uint8*) & (TotZero5[(temp>>2)+5][0]); 675 } 676 else if (temp >= 2) 677 { 678 pcode = (uint8*) & (TotZero5[(temp>>1)+1][0]); 679 } 680 else 681 { 682 pcode = (uint8*) & (TotZero5[temp][0]); 683 } 684 } 685 else if (TotalCoeff >= 6 && TotalCoeff <= 10) 686 { 687 if (TotalCoeff == 10) 688 { 689 BitstreamShowBits(stream, 5, &temp); 690 } 691 else 692 { 693 BitstreamShowBits(stream, 6, &temp); 694 } 695 696 697 if (temp >= 8) 698 { 699 pcode = (uint8*) & (TotZero6to10[TotalCoeff-6][(temp>>3)+7][0]); 700 } 701 else 702 { 703 pcode = (uint8*) & (TotZero6to10[TotalCoeff-6][temp][0]); 704 } 705 } 706 else if (TotalCoeff == 11) 707 { 708 BitstreamShowBits(stream, 4, &temp); 709 710 711 if (temp >= 8) 712 { 713 pcode = (uint8*) & (TotZero11[6][0]); 714 } 715 else if (temp >= 4) 716 { 717 pcode = (uint8*) & (TotZero11[(temp>>1)+2][0]); 718 } 719 else 720 { 721 pcode = (uint8*) & (TotZero11[temp][0]); 722 } 723 } 724 else 725 { 726 BitstreamShowBits(stream, (16 - TotalCoeff), &temp); 727 mask = 1 << (15 - TotalCoeff); 728 indx = 0; 729 while ((temp&mask) == 0 && indx < (16 - TotalCoeff)) /* search location of 1 bit */ 730 { 731 mask >>= 1; 732 indx++; 733 } 734 735 pcode = (uint8*) & (TotZero12to15[TotalCoeff-12][indx]); 736 } 737 738 *code = pcode[0]; 739 BitstreamFlushBits(stream, pcode[1]); 740 741 return AVCDEC_SUCCESS; 742 } 743 744 /* see Table 9-9 */ 745 AVCDec_Status ce_TotalZerosChromaDC(AVCDecBitstream *stream, int *code, int TotalCoeff) 746 { 747 const static uint8 TotZeroChrom1to3[3][8][2] = 748 { 749 {{3, 3}, {2, 3}, {1, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 1}, {0, 1}}, 750 {{2, 2}, {2, 2}, {1, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 1}, {0, 1}}, 751 {{1, 1}, {1, 1}, {1, 1}, {1, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}}, 752 }; 753 754 755 uint temp; 756 uint8 *pcode; 757 758 BitstreamShowBits(stream, 3, &temp); 759 pcode = (uint8*) & (TotZeroChrom1to3[TotalCoeff-1][temp]); 760 761 *code = pcode[0]; 762 763 BitstreamFlushBits(stream, pcode[1]); 764 765 return AVCDEC_SUCCESS; 766 } 767 768 /* see Table 9-10 */ 769 AVCDec_Status ce_RunBefore(AVCDecBitstream *stream, int *code, int zerosLeft) 770 { 771 const static int codlen[6] = {1, 2, 2, 3, 3, 3}; /* num bits to read */ 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 /*const static int RunBefore2[4][2]=*/{{2, 2}, {1, 2}, {0, 1}, {0, 1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}, 774 /*const static int RunBefore3[4][2]=*/{{3, 2}, {2, 2}, {1, 2}, {0, 2}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}, 775 /*const static int RunBefore4[7][2]=*/{{4, 3}, {3, 3}, {2, 2}, {2, 2}, {1, 2}, {1, 2}, {0, 2}, {0, 2}}, 776 /*const static int RunBefore5[7][2]=*/{{5, 3}, {4, 3}, {3, 3}, {2, 3}, {1, 2}, {1, 2}, {0, 2}, {0, 2}}, 777 /*const static int RunBefore6[7][2]=*/{{1, 3}, {2, 3}, {4, 3}, {3, 3}, {6, 3}, {5, 3}, {0, 2}, {0, 2}} 778 }; 779 780 uint temp; 781 uint8 *pcode; 782 int indx; 783 784 if (zerosLeft <= 6) 785 { 786 BitstreamShowBits(stream, codlen[zerosLeft-1], &temp); 787 788 pcode = (uint8*) & (RunBeforeTab[zerosLeft-1][temp][0]); 789 790 *code = pcode[0]; 791 792 BitstreamFlushBits(stream, pcode[1]); 793 } 794 else 795 { 796 BitstreamReadBits(stream, 3, &temp); 797 if (temp) 798 { 799 *code = 7 - temp; 800 } 801 else 802 { 803 BitstreamShowBits(stream, 9, &temp); 804 temp <<= 7; 805 temp |= 1; 806 indx = 0; 807 PV_CLZ(indx, temp) 808 *code = 7 + indx; 809 BitstreamFlushBits(stream, indx + 1); 810 } 811 } 812 813 814 return AVCDEC_SUCCESS; 815 } 816
