1 /* 2 * Copyright (c) 1995 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * Permission to use, copy, modify, and distribute this software and its 6 * documentation for any purpose, without fee, and without written agreement is 7 * hereby granted, provided that the above copyright notice and the following 8 * two paragraphs appear in all copies of this software. 9 * 10 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR 11 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT 12 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF 13 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 14 * 15 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, 16 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 17 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 18 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO 19 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 20 */ 21 /* 22 * decoders.h 23 * 24 * This file contains the declarations of structures required for Huffman 25 * decoding 26 * 27 */ 28 29 /* Include util.h for bit i/o parsing macros. */ 30 31 #include "util.h" 32 33 /* Code for unbound values in decoding tables */ 34 #define ERROR (-1) 35 #define DCT_ERROR 63 36 37 #define MACRO_BLOCK_STUFFING 34 38 #define MACRO_BLOCK_ESCAPE 35 39 40 /* Two types of DCT Coefficients */ 41 #define DCT_COEFF_FIRST 0 42 #define DCT_COEFF_NEXT 1 43 44 /* Special values for DCT Coefficients */ 45 #define END_OF_BLOCK 62 46 #define ESCAPE 61 47 48 /* Structure for an entry in the decoding table of 49 * macroblock_address_increment */ 50 typedef struct { 51 int value; /* value for macroblock_address_increment */ 52 int num_bits; /* length of the Huffman code */ 53 } mb_addr_inc_entry; 54 55 /* Decoding table for macroblock_address_increment */ 56 extern mb_addr_inc_entry mb_addr_inc[2048]; 57 58 59 /* Structure for an entry in the decoding table of macroblock_type */ 60 typedef struct { 61 unsigned int mb_quant; /* macroblock_quant */ 62 unsigned int mb_motion_forward; /* macroblock_motion_forward */ 63 unsigned int mb_motion_backward; /* macroblock_motion_backward */ 64 unsigned int mb_pattern; /* macroblock_pattern */ 65 unsigned int mb_intra; /* macroblock_intra */ 66 int num_bits; /* length of the Huffman code */ 67 } mb_type_entry; 68 69 /* Decoding table for macroblock_type in predictive-coded pictures */ 70 extern mb_type_entry mb_type_P[64]; 71 72 /* Decoding table for macroblock_type in bidirectionally-coded pictures */ 73 extern mb_type_entry mb_type_B[64]; 74 75 76 /* Structures for an entry in the decoding table of coded_block_pattern */ 77 typedef struct { 78 unsigned int cbp; /* coded_block_pattern */ 79 int num_bits; /* length of the Huffman code */ 80 } coded_block_pattern_entry; 81 82 /* External declaration of coded block pattern table. */ 83 84 extern coded_block_pattern_entry coded_block_pattern[512]; 85 86 87 88 /* Structure for an entry in the decoding table of motion vectors */ 89 typedef struct { 90 int code; /* value for motion_horizontal_forward_code, 91 * motion_vertical_forward_code, 92 * motion_horizontal_backward_code, or 93 * motion_vertical_backward_code. 94 */ 95 int num_bits; /* length of the Huffman code */ 96 } motion_vectors_entry; 97 98 99 /* Decoding table for motion vectors */ 100 extern motion_vectors_entry motion_vectors[2048]; 101 102 103 /* Structure for an entry in the decoding table of dct_dc_size */ 104 typedef struct { 105 unsigned int value; /* value of dct_dc_size (luminance or chrominance) */ 106 int num_bits; /* length of the Huffman code */ 107 } dct_dc_size_entry; 108 109 /* External declaration of dct dc size lumiance table. */ 110 111 extern dct_dc_size_entry dct_dc_size_luminance[32]; 112 extern dct_dc_size_entry dct_dc_size_luminance1[16]; 113 114 /* External declaration of dct dc size chrom table. */ 115 116 extern dct_dc_size_entry dct_dc_size_chrominance[32]; 117 extern dct_dc_size_entry dct_dc_size_chrominance1[32]; 118 119 120 /* DCT coeff tables. */ 121 122 #define RUN_MASK 0xfc00 123 #define LEVEL_MASK 0x03f0 124 #define NUM_MASK 0x000f 125 #define RUN_SHIFT 10 126 #define LEVEL_SHIFT 4 127 128 /* External declaration of dct coeff tables. */ 129 130 extern unsigned short int dct_coeff_tbl_0[256]; 131 extern unsigned short int dct_coeff_tbl_1[16]; 132 extern unsigned short int dct_coeff_tbl_2[4]; 133 extern unsigned short int dct_coeff_tbl_3[4]; 134 extern unsigned short int dct_coeff_next[256]; 135 extern unsigned short int dct_coeff_first[256]; 136 137 #define DecodeDCTDCSizeLum(macro_val) \ 138 { \ 139 unsigned int index; \ 140 \ 141 show_bits5(index); \ 142 \ 143 if (index < 31) { \ 144 macro_val = dct_dc_size_luminance[index].value; \ 145 flush_bits(dct_dc_size_luminance[index].num_bits); \ 146 } \ 147 else { \ 148 show_bits9(index); \ 149 index -= 0x1f0; \ 150 macro_val = dct_dc_size_luminance1[index].value; \ 151 flush_bits(dct_dc_size_luminance1[index].num_bits); \ 152 } \ 153 } 154 155 #define DecodeDCTDCSizeChrom(macro_val) \ 156 { \ 157 unsigned int index; \ 158 \ 159 show_bits5(index); \ 160 \ 161 if (index < 31) { \ 162 macro_val = dct_dc_size_chrominance[index].value; \ 163 flush_bits(dct_dc_size_chrominance[index].num_bits); \ 164 } \ 165 else { \ 166 show_bits10(index); \ 167 index -= 0x3e0; \ 168 macro_val = dct_dc_size_chrominance1[index].value; \ 169 flush_bits(dct_dc_size_chrominance1[index].num_bits); \ 170 } \ 171 } 172 173 #define DecodeDCTCoeff(dct_coeff_tbl, run, level) \ 174 { \ 175 unsigned int temp, index; \ 176 unsigned int value, next32bits, flushed; \ 177 \ 178 /* \ 179 * Grab the next 32 bits and use it to improve performance of \ 180 * getting the bits to parse. Thus, calls are translated as: \ 181 * \ 182 * show_bitsX <--> next32bits >> (32-X) \ 183 * get_bitsX <--> val = next32bits >> (32-flushed-X); \ 184 * flushed += X; \ 185 * next32bits &= bitMask[flushed]; \ 186 * flush_bitsX <--> flushed += X; \ 187 * next32bits &= bitMask[flushed]; \ 188 * \ 189 * I've streamlined the code a lot, so that we don't have to mask \ 190 * out the low order bits and a few of the extra adds are removed. \ 191 */ \ 192 show_bits32(next32bits); \ 193 \ 194 /* show_bits8(index); */ \ 195 index = next32bits >> 24; \ 196 \ 197 if (index > 3) { \ 198 value = dct_coeff_tbl[index]; \ 199 run = value >> RUN_SHIFT; \ 200 if (run != END_OF_BLOCK) { \ 201 /* num_bits = (value & NUM_MASK) + 1; */ \ 202 /* flush_bits(num_bits); */ \ 203 if (run != ESCAPE) { \ 204 /* get_bits1(value); */ \ 205 /* if (value) level = -level; */ \ 206 flushed = (value & NUM_MASK) + 2; \ 207 level = (value & LEVEL_MASK) >> LEVEL_SHIFT; \ 208 value = next32bits >> (32-flushed); \ 209 value &= 0x1; \ 210 if (value) level = -level; \ 211 /* next32bits &= ((~0) >> flushed); last op before update */ \ 212 } \ 213 else { /* run == ESCAPE */ \ 214 /* Get the next six into run, and next 8 into temp */ \ 215 /* get_bits14(temp); */ \ 216 flushed = (value & NUM_MASK) + 1; \ 217 temp = next32bits >> (18-flushed); \ 218 /* Normally, we'd ad 14 to flushed, but I've saved a few \ 219 * instr by moving the add below */ \ 220 temp &= 0x3fff; \ 221 run = temp >> 8; \ 222 temp &= 0xff; \ 223 if (temp == 0) { \ 224 /* get_bits8(level); */ \ 225 level = next32bits >> (10-flushed); \ 226 level &= 0xff; \ 227 flushed += 22; \ 228 assert(level >= 128); \ 229 } else if (temp != 128) { \ 230 /* Grab sign bit */ \ 231 flushed += 14; \ 232 level = ((int) (temp << 24)) >> 24; \ 233 } else { \ 234 /* get_bits8(level); */ \ 235 level = next32bits >> (10-flushed); \ 236 level &= 0xff; \ 237 flushed += 22; \ 238 level = level - 256; \ 239 assert(level <= -128 && level >= -255); \ 240 } \ 241 } \ 242 /* Update bitstream... */ \ 243 flush_bits(flushed); \ 244 assert (flushed <= 32); \ 245 } \ 246 } \ 247 else { \ 248 switch (index) { \ 249 case 2: { \ 250 /* show_bits10(index); */ \ 251 index = next32bits >> 22; \ 252 value = dct_coeff_tbl_2[index & 3]; \ 253 break; \ 254 } \ 255 case 3: { \ 256 /* show_bits10(index); */ \ 257 index = next32bits >> 22; \ 258 value = dct_coeff_tbl_3[index & 3]; \ 259 break; \ 260 } \ 261 case 1: { \ 262 /* show_bits12(index); */ \ 263 index = next32bits >> 20; \ 264 value = dct_coeff_tbl_1[index & 15]; \ 265 break; \ 266 } \ 267 default: { /* index == 0 */ \ 268 /* show_bits16(index); */ \ 269 index = next32bits >> 16; \ 270 value = dct_coeff_tbl_0[index & 255]; \ 271 }} \ 272 run = value >> RUN_SHIFT; \ 273 level = (value & LEVEL_MASK) >> LEVEL_SHIFT; \ 274 \ 275 /* \ 276 * Fold these operations together to make it fast... \ 277 */ \ 278 /* num_bits = (value & NUM_MASK) + 1; */ \ 279 /* flush_bits(num_bits); */ \ 280 /* get_bits1(value); */ \ 281 /* if (value) level = -level; */ \ 282 \ 283 flushed = (value & NUM_MASK) + 2; \ 284 value = next32bits >> (32-flushed); \ 285 value &= 0x1; \ 286 if (value) level = -level; \ 287 \ 288 /* Update bitstream ... */ \ 289 flush_bits(flushed); \ 290 assert (flushed <= 32); \ 291 } \ 292 } 293 294 #define DecodeDCTCoeffFirst(runval, levelval) \ 295 { \ 296 DecodeDCTCoeff(dct_coeff_first, runval, levelval); \ 297 } 298 299 #define DecodeDCTCoeffNext(runval, levelval) \ 300 { \ 301 DecodeDCTCoeff(dct_coeff_next, runval, levelval); \ 302 } 303 304 /* 305 *-------------------------------------------------------------- 306 * 307 * DecodeMBAddrInc -- 308 * 309 * Huffman Decoder for macro_block_address_increment; the location 310 * in which the result will be placed is being passed as argument. 311 * The decoded value is obtained by doing a table lookup on 312 * mb_addr_inc. 313 * 314 * Results: 315 * The decoded value for macro_block_address_increment or ERROR 316 * for unbound values will be placed in the location specified. 317 * 318 * Side effects: 319 * Bit stream is irreversibly parsed. 320 * 321 *-------------------------------------------------------------- 322 */ 323 #define DecodeMBAddrInc(val) \ 324 { \ 325 unsigned int index; \ 326 show_bits11(index); \ 327 val = mb_addr_inc[index].value; \ 328 flush_bits(mb_addr_inc[index].num_bits); \ 329 } 330 331 /* 332 *-------------------------------------------------------------- 333 * 334 * DecodeMotionVectors -- 335 * 336 * Huffman Decoder for the various motion vectors, including 337 * motion_horizontal_forward_code, motion_vertical_forward_code, 338 * motion_horizontal_backward_code, motion_vertical_backward_code. 339 * Location where the decoded result will be placed is being passed 340 * as argument. The decoded values are obtained by doing a table 341 * lookup on motion_vectors. 342 * 343 * Results: 344 * The decoded value for the motion vector or ERROR for unbound 345 * values will be placed in the location specified. 346 * 347 * Side effects: 348 * Bit stream is irreversibly parsed. 349 * 350 *-------------------------------------------------------------- 351 */ 352 353 #define DecodeMotionVectors(value) \ 354 { \ 355 unsigned int index; \ 356 show_bits11(index); \ 357 value = motion_vectors[index].code; \ 358 flush_bits(motion_vectors[index].num_bits); \ 359 } 360 /* 361 *-------------------------------------------------------------- 362 * 363 * DecodeMBTypeB -- 364 * 365 * Huffman Decoder for macro_block_type in bidirectionally-coded 366 * pictures;locations in which the decoded results: macroblock_quant, 367 * macroblock_motion_forward, macro_block_motion_backward, 368 * macroblock_pattern, macro_block_intra, will be placed are 369 * being passed as argument. The decoded values are obtained by 370 * doing a table lookup on mb_type_B. 371 * 372 * Results: 373 * The various decoded values for macro_block_type in 374 * bidirectionally-coded pictures or ERROR for unbound values will 375 * be placed in the locations specified. 376 * 377 * Side effects: 378 * Bit stream is irreversibly parsed. 379 * 380 *-------------------------------------------------------------- 381 */ 382 #define DecodeMBTypeB(quant, motion_fwd, motion_bwd, pat, intra) \ 383 { \ 384 unsigned int index; \ 385 \ 386 show_bits6(index); \ 387 \ 388 quant = mb_type_B[index].mb_quant; \ 389 motion_fwd = mb_type_B[index].mb_motion_forward; \ 390 motion_bwd = mb_type_B[index].mb_motion_backward; \ 391 pat = mb_type_B[index].mb_pattern; \ 392 intra = mb_type_B[index].mb_intra; \ 393 flush_bits(mb_type_B[index].num_bits); \ 394 } 395 /* 396 *-------------------------------------------------------------- 397 * 398 * DecodeMBTypeI -- 399 * 400 * Huffman Decoder for macro_block_type in intra-coded pictures; 401 * locations in which the decoded results: macroblock_quant, 402 * macroblock_motion_forward, macro_block_motion_backward, 403 * macroblock_pattern, macro_block_intra, will be placed are 404 * being passed as argument. 405 * 406 * Results: 407 * The various decoded values for macro_block_type in intra-coded 408 * pictures or ERROR for unbound values will be placed in the 409 * locations specified. 410 * 411 * Side effects: 412 * Bit stream is irreversibly parsed. 413 * 414 *-------------------------------------------------------------- 415 */ 416 #define DecodeMBTypeI(quant, motion_fwd, motion_bwd, pat, intra) \ 417 { \ 418 unsigned int index; \ 419 static int quantTbl[4] = {ERROR, 1, 0, 0}; \ 420 \ 421 show_bits2(index); \ 422 \ 423 motion_fwd = 0; \ 424 motion_bwd = 0; \ 425 pat = 0; \ 426 intra = 1; \ 427 quant = quantTbl[index]; \ 428 if (index) { \ 429 flush_bits (1 + quant); \ 430 } \ 431 } 432 /* 433 *-------------------------------------------------------------- 434 * 435 * DecodeMBTypeP -- 436 * 437 * Huffman Decoder for macro_block_type in predictive-coded pictures; 438 * locations in which the decoded results: macroblock_quant, 439 * macroblock_motion_forward, macro_block_motion_backward, 440 * macroblock_pattern, macro_block_intra, will be placed are 441 * being passed as argument. The decoded values are obtained by 442 * doing a table lookup on mb_type_P. 443 * 444 * Results: 445 * The various decoded values for macro_block_type in 446 * predictive-coded pictures or ERROR for unbound values will be 447 * placed in the locations specified. 448 * 449 * Side effects: 450 * Bit stream is irreversibly parsed. 451 * 452 *-------------------------------------------------------------- 453 */ 454 #define DecodeMBTypeP(quant, motion_fwd, motion_bwd, pat, intra) \ 455 { \ 456 unsigned int index; \ 457 \ 458 show_bits6(index); \ 459 \ 460 quant = mb_type_P[index].mb_quant; \ 461 motion_fwd = mb_type_P[index].mb_motion_forward; \ 462 motion_bwd = mb_type_P[index].mb_motion_backward; \ 463 pat = mb_type_P[index].mb_pattern; \ 464 intra = mb_type_P[index].mb_intra; \ 465 \ 466 flush_bits(mb_type_P[index].num_bits); \ 467 } 468 /* 469 *-------------------------------------------------------------- 470 * 471 * DecodeCBP -- 472 * 473 * Huffman Decoder for coded_block_pattern; location in which the 474 * decoded result will be placed is being passed as argument. The 475 * decoded values are obtained by doing a table lookup on 476 * coded_block_pattern. 477 * 478 * Results: 479 * The decoded value for coded_block_pattern or ERROR for unbound 480 * values will be placed in the location specified. 481 * 482 * Side effects: 483 * Bit stream is irreversibly parsed. 484 * 485 *-------------------------------------------------------------- 486 */ 487 #define DecodeCBP(coded_bp) \ 488 { \ 489 unsigned int index; \ 490 \ 491 show_bits9(index); \ 492 coded_bp = coded_block_pattern[index].cbp; \ 493 flush_bits(coded_block_pattern[index].num_bits); \ 494 } 495