src/gallium/auxiliary/vl/vl_mpeg12_bitstream.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2011 Maarten Lankhorst
   4  * Copyright 2011 Christian König
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 #include "pipe/p_video_codec.h"
  30 #include "util/u_memory.h"
  31
  32 #include "vl_vlc.h"
  33 #include "vl_mpeg12_bitstream.h"
  34
  35 enum {
  36    dct_End_of_Block = 0xFF,
  37    dct_Escape = 0xFE,
  38    dct_DC = 0xFD,
  39    dct_AC = 0xFC
  40 };
  41
  42 struct dct_coeff
  43 {
  44    uint8_t length;
  45    uint8_t run;
  46    int16_t level;
  47 };
  48
  49 struct dct_coeff_compressed
  50 {
  51    uint32_t bitcode;
  52    struct dct_coeff coeff;
  53 };
  54
  55 /* coding table as found in the spec annex B.5 table B-1 */
  56 static const struct vl_vlc_compressed macroblock_address_increment[] = {
  57    { 0x8000, { 1, 1 } },
  58    { 0x6000, { 3, 2 } },
  59    { 0x4000, { 3, 3 } },
  60    { 0x3000, { 4, 4 } },
  61    { 0x2000, { 4, 5 } },
  62    { 0x1800, { 5, 6 } },
  63    { 0x1000, { 5, 7 } },
  64    { 0x0e00, { 7, 8 } },
  65    { 0x0c00, { 7, 9 } },
  66    { 0x0b00, { 8, 10 } },
  67    { 0x0a00, { 8, 11 } },
  68    { 0x0900, { 8, 12 } },
  69    { 0x0800, { 8, 13 } },
  70    { 0x0700, { 8, 14 } },
  71    { 0x0600, { 8, 15 } },
  72    { 0x05c0, { 10, 16 } },
  73    { 0x0580, { 10, 17 } },
  74    { 0x0540, { 10, 18 } },
  75    { 0x0500, { 10, 19 } },
  76    { 0x04c0, { 10, 20 } },
  77    { 0x0480, { 10, 21 } },
  78    { 0x0460, { 11, 22 } },
  79    { 0x0440, { 11, 23 } },
  80    { 0x0420, { 11, 24 } },
  81    { 0x0400, { 11, 25 } },
  82    { 0x03e0, { 11, 26 } },
  83    { 0x03c0, { 11, 27 } },
  84    { 0x03a0, { 11, 28 } },
  85    { 0x0380, { 11, 29 } },
  86    { 0x0360, { 11, 30 } },
  87    { 0x0340, { 11, 31 } },
  88    { 0x0320, { 11, 32 } },
  89    { 0x0300, { 11, 33 } }
  90 };
  91
  92 #define Q PIPE_MPEG12_MB_TYPE_QUANT
  93 #define F PIPE_MPEG12_MB_TYPE_MOTION_FORWARD
  94 #define B PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD
  95 #define P PIPE_MPEG12_MB_TYPE_PATTERN
  96 #define I PIPE_MPEG12_MB_TYPE_INTRA
  97
  98 /* coding table as found in the spec annex B.5 table B-2 */
  99 static const struct vl_vlc_compressed macroblock_type_i[] = {
 100    { 0x8000, { 1, I } },
 101    { 0x4000, { 2, Q|I } }
 102 };
 103
 104 /* coding table as found in the spec annex B.5 table B-3 */
 105 static const struct vl_vlc_compressed macroblock_type_p[] = {
 106    { 0x8000, { 1, F|P } },
 107    { 0x4000, { 2, P } },
 108    { 0x2000, { 3, F } },
 109    { 0x1800, { 5, I } },
 110    { 0x1000, { 5, Q|F|P } },
 111    { 0x0800, { 5, Q|P } },
 112    { 0x0400, { 6, Q|I } }
 113 };
 114
 115 /* coding table as found in the spec annex B.5 table B-4 */
 116 static const struct vl_vlc_compressed macroblock_type_b[] = {
 117    { 0x8000, { 2, F|B } },
 118    { 0xC000, { 2, F|B|P } },
 119    { 0x4000, { 3, B } },
 120    { 0x6000, { 3, B|P } },
 121    { 0x2000, { 4, F } },
 122    { 0x3000, { 4, F|P } },
 123    { 0x1800, { 5, I } },
 124    { 0x1000, { 5, Q|F|B|P } },
 125    { 0x0C00, { 6, Q|F|P } },
 126    { 0x0800, { 6, Q|B|P } },
 127    { 0x0400, { 6, Q|I } }
 128 };
 129
 130 #undef Q
 131 #undef F
 132 #undef B
 133 #undef P
 134 #undef I
 135
 136 /* coding table as found in the spec annex B.5 table B-9 */
 137 static const struct vl_vlc_compressed coded_block_pattern[] = {
 138    { 0xE000, { 3, 60 } },
 139    { 0xD000, { 4, 4 } },
 140    { 0xC000, { 4, 8 } },
 141    { 0xB000, { 4, 16 } },
 142    { 0xA000, { 4, 32 } },
 143    { 0x9800, { 5, 12 } },
 144    { 0x9000, { 5, 48 } },
 145    { 0x8800, { 5, 20 } },
 146    { 0x8000, { 5, 40 } },
 147    { 0x7800, { 5, 28 } },
 148    { 0x7000, { 5, 44 } },
 149    { 0x6800, { 5, 52 } },
 150    { 0x6000, { 5, 56 } },
 151    { 0x5800, { 5, 1 } },
 152    { 0x5000, { 5, 61 } },
 153    { 0x4800, { 5, 2 } },
 154    { 0x4000, { 5, 62 } },
 155    { 0x3C00, { 6, 24 } },
 156    { 0x3800, { 6, 36 } },
 157    { 0x3400, { 6, 3 } },
 158    { 0x3000, { 6, 63 } },
 159    { 0x2E00, { 7, 5 } },
 160    { 0x2C00, { 7, 9 } },
 161    { 0x2A00, { 7, 17 } },
 162    { 0x2800, { 7, 33 } },
 163    { 0x2600, { 7, 6 } },
 164    { 0x2400, { 7, 10 } },
 165    { 0x2200, { 7, 18 } },
 166    { 0x2000, { 7, 34 } },
 167    { 0x1F00, { 8, 7 } },
 168    { 0x1E00, { 8, 11 } },
 169    { 0x1D00, { 8, 19 } },
 170    { 0x1C00, { 8, 35 } },
 171    { 0x1B00, { 8, 13 } },
 172    { 0x1A00, { 8, 49 } },
 173    { 0x1900, { 8, 21 } },
 174    { 0x1800, { 8, 41 } },
 175    { 0x1700, { 8, 14 } },
 176    { 0x1600, { 8, 50 } },
 177    { 0x1500, { 8, 22 } },
 178    { 0x1400, { 8, 42 } },
 179    { 0x1300, { 8, 15 } },
 180    { 0x1200, { 8, 51 } },
 181    { 0x1100, { 8, 23 } },
 182    { 0x1000, { 8, 43 } },
 183    { 0x0F00, { 8, 25 } },
 184    { 0x0E00, { 8, 37 } },
 185    { 0x0D00, { 8, 26 } },
 186    { 0x0C00, { 8, 38 } },
 187    { 0x0B00, { 8, 29 } },
 188    { 0x0A00, { 8, 45 } },
 189    { 0x0900, { 8, 53 } },
 190    { 0x0800, { 8, 57 } },
 191    { 0x0700, { 8, 30 } },
 192    { 0x0600, { 8, 46 } },
 193    { 0x0500, { 8, 54 } },
 194    { 0x0400, { 8, 58 } },
 195    { 0x0380, { 9, 31 } },
 196    { 0x0300, { 9, 47 } },
 197    { 0x0280, { 9, 55 } },
 198    { 0x0200, { 9, 59 } },
 199    { 0x0180, { 9, 27 } },
 200    { 0x0100, { 9, 39 } },
 201    { 0x0080, { 9, 0 } }
 202 };
 203
 204 /* coding table as found in the spec annex B.5 table B-10 */
 205 static const struct vl_vlc_compressed motion_code[] = {
 206    { 0x0320, { 11, -16 } },
 207    { 0x0360, { 11, -15 } },
 208    { 0x03a0, { 11, -14 } },
 209    { 0x03e0, { 11, -13 } },
 210    { 0x0420, { 11, -12 } },
 211    { 0x0460, { 11, -11 } },
 212    { 0x04c0, { 10, -10 } },
 213    { 0x0540, { 10, -9 } },
 214    { 0x05c0, { 10, -8 } },
 215    { 0x0700, { 8, -7 } },
 216    { 0x0900, { 8, -6 } },
 217    { 0x0b00, { 8, -5 } },
 218    { 0x0e00, { 7, -4 } },
 219    { 0x1800, { 5, -3 } },
 220    { 0x3000, { 4, -2 } },
 221    { 0x6000, { 3, -1 } },
 222    { 0x8000, { 1, 0 } },
 223    { 0x4000, { 3, 1 } },
 224    { 0x2000, { 4, 2 } },
 225    { 0x1000, { 5, 3 } },
 226    { 0x0c00, { 7, 4 } },
 227    { 0x0a00, { 8, 5 } },
 228    { 0x0800, { 8, 6 } },
 229    { 0x0600, { 8, 7 } },
 230    { 0x0580, { 10, 8 } },
 231    { 0x0500, { 10, 9 } },
 232    { 0x0480, { 10, 10 } },
 233    { 0x0440, { 11, 11 } },
 234    { 0x0400, { 11, 12 } },
 235    { 0x03c0, { 11, 13 } },
 236    { 0x0380, { 11, 14 } },
 237    { 0x0340, { 11, 15 } },
 238    { 0x0300, { 11, 16 } }
 239 };
 240
 241 /* coding table as found in the spec annex B.5 table B-11 */
 242 static const struct vl_vlc_compressed dmvector[] = {
 243    { 0x0000, { 1, 0 } },
 244    { 0x8000, { 2, 1 } },
 245    { 0xc000, { 2, -1 } }
 246 };
 247
 248 /* coding table as found in the spec annex B.5 table B-12 */
 249 static const struct vl_vlc_compressed dct_dc_size_luminance[] = {
 250    { 0x8000, { 3, 0 } },
 251    { 0x0000, { 2, 1 } },
 252    { 0x4000, { 2, 2 } },
 253    { 0xA000, { 3, 3 } },
 254    { 0xC000, { 3, 4 } },
 255    { 0xE000, { 4, 5 } },
 256    { 0xF000, { 5, 6 } },
 257    { 0xF800, { 6, 7 } },
 258    { 0xFC00, { 7, 8 } },
 259    { 0xFE00, { 8, 9 } },
 260    { 0xFF00, { 9, 10 } },
 261    { 0xFF80, { 9, 11 } }
 262 };
 263
 264 /* coding table as found in the spec annex B.5 table B-13 */
 265 static const struct vl_vlc_compressed dct_dc_size_chrominance[] = {
 266    { 0x0000, { 2, 0 } },
 267    { 0x4000, { 2, 1 } },
 268    { 0x8000, { 2, 2 } },
 269    { 0xC000, { 3, 3 } },
 270    { 0xE000, { 4, 4 } },
 271    { 0xF000, { 5, 5 } },
 272    { 0xF800, { 6, 6 } },
 273    { 0xFC00, { 7, 7 } },
 274    { 0xFE00, { 8, 8 } },
 275    { 0xFF00, { 9, 9 } },
 276    { 0xFF80, { 10, 10 } },
 277    { 0xFFC0, { 10, 11 } }
 278 };
 279
 280 /* coding table as found in the spec annex B.5 table B-14 */
 281 static const struct dct_coeff_compressed dct_coeff_tbl_zero[] = {
 282    { 0x8000, { 2, dct_End_of_Block, 0 } },
 283    { 0x8000, { 1, dct_DC, 1 } },
 284    { 0xC000, { 2, dct_AC, 1 } },
 285    { 0x6000, { 3, 1, 1 } },
 286    { 0x4000, { 4, 0, 2 } },
 287    { 0x5000, { 4, 2, 1 } },
 288    { 0x2800, { 5, 0, 3 } },
 289    { 0x3800, { 5, 3, 1 } },
 290    { 0x3000, { 5, 4, 1 } },
 291    { 0x1800, { 6, 1, 2 } },
 292    { 0x1C00, { 6, 5, 1 } },
 293    { 0x1400, { 6, 6, 1 } },
 294    { 0x1000, { 6, 7, 1 } },
 295    { 0x0C00, { 7, 0, 4 } },
 296    { 0x0800, { 7, 2, 2 } },
 297    { 0x0E00, { 7, 8, 1 } },
 298    { 0x0A00, { 7, 9, 1 } },
 299    { 0x0400, { 6, dct_Escape, 0 } },
 300    { 0x2600, { 8, 0, 5 } },
 301    { 0x2100, { 8, 0, 6 } },
 302    { 0x2500, { 8, 1, 3 } },
 303    { 0x2400, { 8, 3, 2 } },
 304    { 0x2700, { 8, 10, 1 } },
 305    { 0x2300, { 8, 11, 1 } },
 306    { 0x2200, { 8, 12, 1 } },
 307    { 0x2000, { 8, 13, 1 } },
 308    { 0x0280, { 10, 0, 7 } },
 309    { 0x0300, { 10, 1, 4 } },
 310    { 0x02C0, { 10, 2, 3 } },
 311    { 0x03C0, { 10, 4, 2 } },
 312    { 0x0240, { 10, 5, 2 } },
 313    { 0x0380, { 10, 14, 1 } },
 314    { 0x0340, { 10, 15, 1 } },
 315    { 0x0200, { 10, 16, 1 } },
 316    { 0x01D0, { 12, 0, 8 } },
 317    { 0x0180, { 12, 0, 9 } },
 318    { 0x0130, { 12, 0, 10 } },
 319    { 0x0100, { 12, 0, 11 } },
 320    { 0x01B0, { 12, 1, 5 } },
 321    { 0x0140, { 12, 2, 4 } },
 322    { 0x01C0, { 12, 3, 3 } },
 323    { 0x0120, { 12, 4, 3 } },
 324    { 0x01E0, { 12, 6, 2 } },
 325    { 0x0150, { 12, 7, 2 } },
 326    { 0x0110, { 12, 8, 2 } },
 327    { 0x01F0, { 12, 17, 1 } },
 328    { 0x01A0, { 12, 18, 1 } },
 329    { 0x0190, { 12, 19, 1 } },
 330    { 0x0170, { 12, 20, 1 } },
 331    { 0x0160, { 12, 21, 1 } },
 332    { 0x00D0, { 13, 0, 12 } },
 333    { 0x00C8, { 13, 0, 13 } },
 334    { 0x00C0, { 13, 0, 14 } },
 335    { 0x00B8, { 13, 0, 15 } },
 336    { 0x00B0, { 13, 1, 6 } },
 337    { 0x00A8, { 13, 1, 7 } },
 338    { 0x00A0, { 13, 2, 5 } },
 339    { 0x0098, { 13, 3, 4 } },
 340    { 0x0090, { 13, 5, 3 } },
 341    { 0x0088, { 13, 9, 2 } },
 342    { 0x0080, { 13, 10, 2 } },
 343    { 0x00F8, { 13, 22, 1 } },
 344    { 0x00F0, { 13, 23, 1 } },
 345    { 0x00E8, { 13, 24, 1 } },
 346    { 0x00E0, { 13, 25, 1 } },
 347    { 0x00D8, { 13, 26, 1 } },
 348    { 0x007C, { 14, 0, 16 } },
 349    { 0x0078, { 14, 0, 17 } },
 350    { 0x0074, { 14, 0, 18 } },
 351    { 0x0070, { 14, 0, 19 } },
 352    { 0x006C, { 14, 0, 20 } },
 353    { 0x0068, { 14, 0, 21 } },
 354    { 0x0064, { 14, 0, 22 } },
 355    { 0x0060, { 14, 0, 23 } },
 356    { 0x005C, { 14, 0, 24 } },
 357    { 0x0058, { 14, 0, 25 } },
 358    { 0x0054, { 14, 0, 26 } },
 359    { 0x0050, { 14, 0, 27 } },
 360    { 0x004C, { 14, 0, 28 } },
 361    { 0x0048, { 14, 0, 29 } },
 362    { 0x0044, { 14, 0, 30 } },
 363    { 0x0040, { 14, 0, 31 } },
 364    { 0x0030, { 15, 0, 32 } },
 365    { 0x002E, { 15, 0, 33 } },
 366    { 0x002C, { 15, 0, 34 } },
 367    { 0x002A, { 15, 0, 35 } },
 368    { 0x0028, { 15, 0, 36 } },
 369    { 0x0026, { 15, 0, 37 } },
 370    { 0x0024, { 15, 0, 38 } },
 371    { 0x0022, { 15, 0, 39 } },
 372    { 0x0020, { 15, 0, 40 } },
 373    { 0x003E, { 15, 1, 8 } },
 374    { 0x003C, { 15, 1, 9 } },
 375    { 0x003A, { 15, 1, 10 } },
 376    { 0x0038, { 15, 1, 11 } },
 377    { 0x0036, { 15, 1, 12 } },
 378    { 0x0034, { 15, 1, 13 } },
 379    { 0x0032, { 15, 1, 14 } },
 380    { 0x0013, { 16, 1, 15 } },
 381    { 0x0012, { 16, 1, 16 } },
 382    { 0x0011, { 16, 1, 17 } },
 383    { 0x0010, { 16, 1, 18 } },
 384    { 0x0014, { 16, 6, 3 } },
 385    { 0x001A, { 16, 11, 2 } },
 386    { 0x0019, { 16, 12, 2 } },
 387    { 0x0018, { 16, 13, 2 } },
 388    { 0x0017, { 16, 14, 2 } },
 389    { 0x0016, { 16, 15, 2 } },
 390    { 0x0015, { 16, 16, 2 } },
 391    { 0x001F, { 16, 27, 1 } },
 392    { 0x001E, { 16, 28, 1 } },
 393    { 0x001D, { 16, 29, 1 } },
 394    { 0x001C, { 16, 30, 1 } },
 395    { 0x001B, { 16, 31, 1 } }
 396 };
 397
 398 /* coding table as found in the spec annex B.5 table B-15 */
 399 static const struct dct_coeff_compressed dct_coeff_tbl_one[] = {
 400    { 0x6000, { 4, dct_End_of_Block, 0 } },
 401    { 0x8000, { 2, 0, 1 } },
 402    { 0x4000, { 3, 1, 1 } },
 403    { 0xC000, { 3, 0, 2 } },
 404    { 0x2800, { 5, 2, 1 } },
 405    { 0x7000, { 4, 0, 3 } },
 406    { 0x3800, { 5, 3, 1 } },
 407    { 0x1800, { 6, 4, 1 } },
 408    { 0x3000, { 5, 1, 2 } },
 409    { 0x1C00, { 6, 5, 1 } },
 410    { 0x0C00, { 7, 6, 1 } },
 411    { 0x0800, { 7, 7, 1 } },
 412    { 0xE000, { 5, 0, 4 } },
 413    { 0x0E00, { 7, 2, 2 } },
 414    { 0x0A00, { 7, 8, 1 } },
 415    { 0xF000, { 7, 9, 1 } },
 416    { 0x0400, { 6, dct_Escape, 0 } },
 417    { 0xE800, { 5, 0, 5 } },
 418    { 0x1400, { 6, 0, 6 } },
 419    { 0xF200, { 7, 1, 3 } },
 420    { 0x2600, { 8, 3, 2 } },
 421    { 0xF400, { 7, 10, 1 } },
 422    { 0x2100, { 8, 11, 1 } },
 423    { 0x2500, { 8, 12, 1 } },
 424    { 0x2400, { 8, 13, 1 } },
 425    { 0x1000, { 6, 0, 7 } },
 426    { 0x2700, { 8, 1, 4 } },
 427    { 0xFC00, { 8, 2, 3 } },
 428    { 0xFD00, { 8, 4, 2 } },
 429    { 0x0200, { 9, 5, 2 } },
 430    { 0x0280, { 9, 14, 1 } },
 431    { 0x0380, { 9, 15, 1 } },
 432    { 0x0340, { 10, 16, 1 } },
 433    { 0xF600, { 7, 0, 8 } },
 434    { 0xF800, { 7, 0, 9 } },
 435    { 0x2300, { 8, 0, 10 } },
 436    { 0x2200, { 8, 0, 11 } },
 437    { 0x2000, { 8, 1, 5 } },
 438    { 0x0300, { 10, 2, 4 } },
 439    { 0x01C0, { 12, 3, 3 } },
 440    { 0x0120, { 12, 4, 3 } },
 441    { 0x01E0, { 12, 6, 2 } },
 442    { 0x0150, { 12, 7, 2 } },
 443    { 0x0110, { 12, 8, 2 } },
 444    { 0x01F0, { 12, 17, 1 } },
 445    { 0x01A0, { 12, 18, 1 } },
 446    { 0x0190, { 12, 19, 1 } },
 447    { 0x0170, { 12, 20, 1 } },
 448    { 0x0160, { 12, 21, 1 } },
 449    { 0xFA00, { 8, 0, 12 } },
 450    { 0xFB00, { 8, 0, 13 } },
 451    { 0xFE00, { 8, 0, 14 } },
 452    { 0xFF00, { 8, 0, 15 } },
 453    { 0x00B0, { 13, 1, 6 } },
 454    { 0x00A8, { 13, 1, 7 } },
 455    { 0x00A0, { 13, 2, 5 } },
 456    { 0x0098, { 13, 3, 4 } },
 457    { 0x0090, { 13, 5, 3 } },
 458    { 0x0088, { 13, 9, 2 } },
 459    { 0x0080, { 13, 10, 2 } },
 460    { 0x00F8, { 13, 22, 1 } },
 461    { 0x00F0, { 13, 23, 1 } },
 462    { 0x00E8, { 13, 24, 1 } },
 463    { 0x00E0, { 13, 25, 1 } },
 464    { 0x00D8, { 13, 26, 1 } },
 465    { 0x007C, { 14, 0, 16 } },
 466    { 0x0078, { 14, 0, 17 } },
 467    { 0x0074, { 14, 0, 18 } },
 468    { 0x0070, { 14, 0, 19 } },
 469    { 0x006C, { 14, 0, 20 } },
 470    { 0x0068, { 14, 0, 21 } },
 471    { 0x0064, { 14, 0, 22 } },
 472    { 0x0060, { 14, 0, 23 } },
 473    { 0x005C, { 14, 0, 24 } },
 474    { 0x0058, { 14, 0, 25 } },
 475    { 0x0054, { 14, 0, 26 } },
 476    { 0x0050, { 14, 0, 27 } },
 477    { 0x004C, { 14, 0, 28 } },
 478    { 0x0048, { 14, 0, 29 } },
 479    { 0x0044, { 14, 0, 30 } },
 480    { 0x0040, { 14, 0, 31 } },
 481    { 0x0030, { 15, 0, 32 } },
 482    { 0x002E, { 15, 0, 33 } },
 483    { 0x002C, { 15, 0, 34 } },
 484    { 0x002A, { 15, 0, 35 } },
 485    { 0x0028, { 15, 0, 36 } },
 486    { 0x0026, { 15, 0, 37 } },
 487    { 0x0024, { 15, 0, 38 } },
 488    { 0x0022, { 15, 0, 39 } },
 489    { 0x0020, { 15, 0, 40 } },
 490    { 0x003E, { 15, 1, 8 } },
 491    { 0x003C, { 15, 1, 9 } },
 492    { 0x003A, { 15, 1, 10 } },
 493    { 0x0038, { 15, 1, 11 } },
 494    { 0x0036, { 15, 1, 12 } },
 495    { 0x0034, { 15, 1, 13 } },
 496    { 0x0032, { 15, 1, 14 } },
 497    { 0x0013, { 16, 1, 15 } },
 498    { 0x0012, { 16, 1, 16 } },
 499    { 0x0011, { 16, 1, 17 } },
 500    { 0x0010, { 16, 1, 18 } },
 501    { 0x0014, { 16, 6, 3 } },
 502    { 0x001A, { 16, 11, 2 } },
 503    { 0x0019, { 16, 12, 2 } },
 504    { 0x0018, { 16, 13, 2 } },
 505    { 0x0017, { 16, 14, 2 } },
 506    { 0x0016, { 16, 15, 2 } },
 507    { 0x0015, { 16, 16, 2 } },
 508    { 0x001F, { 16, 27, 1 } },
 509    { 0x001E, { 16, 28, 1 } },
 510    { 0x001D, { 16, 29, 1 } },
 511    { 0x001C, { 16, 30, 1 } },
 512    { 0x001B, { 16, 31, 1 } }
 513 };
 514
 515 /* q_scale_type */
 516 static const unsigned quant_scale[2][32] = {
 517   { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30,
 518     32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62 },
 519   { 0, 1, 2, 3, 4,  5,  6,  7,  8, 10, 12, 14, 16, 18, 20, 22, 24,
 520     28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 96, 104, 112 }
 521 };
 522
 523 static struct vl_vlc_entry tbl_B1[1 << 11];
 524 static struct vl_vlc_entry tbl_B2[1 << 2];
 525 static struct vl_vlc_entry tbl_B3[1 << 6];
 526 static struct vl_vlc_entry tbl_B4[1 << 6];
 527 static struct vl_vlc_entry tbl_B9[1 << 9];
 528 static struct vl_vlc_entry tbl_B10[1 << 11];
 529 static struct vl_vlc_entry tbl_B11[1 << 2];
 530 static struct vl_vlc_entry tbl_B12[1 << 10];
 531 static struct vl_vlc_entry tbl_B13[1 << 10];
 532 static struct dct_coeff tbl_B14_DC[1 << 17];
 533 static struct dct_coeff tbl_B14_AC[1 << 17];
 534 static struct dct_coeff tbl_B15[1 << 17];
 535
 536 static INLINE void
 537 init_dct_coeff_table(struct dct_coeff *dst, const struct dct_coeff_compressed *src,
 538                      unsigned size, bool is_DC)
 539 {
 540    unsigned i;
 541
 542    for (i=0;i<(1<<17);++i) {
 543       dst[i].length = 0;
 544       dst[i].level = 0;
 545       dst[i].run = dct_End_of_Block;
 546    }
 547
 548    for(; size > 0; --size, ++src) {
 549       struct dct_coeff coeff = src->coeff;
 550       bool has_sign = true;
 551
 552       switch (coeff.run) {
 553       case dct_End_of_Block:
 554          if (is_DC)
 555             continue;
 556
 557          has_sign = false;
 558          break;
 559
 560       case dct_Escape:
 561          has_sign = false;
 562          break;
 563
 564       case dct_DC:
 565          if (!is_DC)
 566             continue;
 567
 568          coeff.length += 1;
 569          coeff.run = 1;
 570          break;
 571
 572       case dct_AC:
 573          if (is_DC)
 574             continue;
 575
 576          coeff.length += 1;
 577          coeff.run = 1;
 578          break;
 579
 580       default:
 581          coeff.length += 1;
 582          coeff.run += 1;
 583          break;
 584       }
 585
 586       for(i=0; i<(1 << (17 - coeff.length)); ++i)
 587          dst[src->bitcode << 1 | i] = coeff;
 588
 589       if (has_sign) {
 590          coeff.level = -coeff.level;
 591          for(; i<(1 << (18 - coeff.length)); ++i)
 592             dst[src->bitcode << 1 | i] = coeff;
 593       }
 594    }
 595 }
 596
 597 static INLINE void
 598 init_tables()
 599 {
 600    vl_vlc_init_table(tbl_B1, Elements(tbl_B1), macroblock_address_increment, Elements(macroblock_address_increment));
 601    vl_vlc_init_table(tbl_B2, Elements(tbl_B2), macroblock_type_i, Elements(macroblock_type_i));
 602    vl_vlc_init_table(tbl_B3, Elements(tbl_B3), macroblock_type_p, Elements(macroblock_type_p));
 603    vl_vlc_init_table(tbl_B4, Elements(tbl_B4), macroblock_type_b, Elements(macroblock_type_b));
 604    vl_vlc_init_table(tbl_B9, Elements(tbl_B9), coded_block_pattern, Elements(coded_block_pattern));
 605    vl_vlc_init_table(tbl_B10, Elements(tbl_B10), motion_code, Elements(motion_code));
 606    vl_vlc_init_table(tbl_B11, Elements(tbl_B11), dmvector, Elements(dmvector));
 607    vl_vlc_init_table(tbl_B12, Elements(tbl_B12), dct_dc_size_luminance, Elements(dct_dc_size_luminance));
 608    vl_vlc_init_table(tbl_B13, Elements(tbl_B13), dct_dc_size_chrominance, Elements(dct_dc_size_chrominance));
 609    init_dct_coeff_table(tbl_B14_DC, dct_coeff_tbl_zero, Elements(dct_coeff_tbl_zero), true);
 610    init_dct_coeff_table(tbl_B14_AC, dct_coeff_tbl_zero, Elements(dct_coeff_tbl_zero), false);
 611    init_dct_coeff_table(tbl_B15, dct_coeff_tbl_one, Elements(dct_coeff_tbl_one), false);
 612 }
 613
 614 static INLINE int
 615 DIV2DOWN(int todiv)
 616 {
 617    return (todiv&~1)/2;
 618 }
 619
 620 static INLINE int
 621 DIV2UP(int todiv)
 622 {
 623    return (todiv+1)/2;
 624 }
 625
 626 static INLINE void
 627 motion_vector(struct vl_mpg12_bs *bs, int r, int s, int dmv, short delta[2], short dmvector[2])
 628 {
 629    int t;
 630    for (t = 0; t < 2; ++t) {
 631       int motion_code;
 632       int r_size = bs->desc->f_code[s][t];
 633
 634       vl_vlc_fillbits(&bs->vlc);
 635       motion_code = vl_vlc_get_vlclbf(&bs->vlc, tbl_B10, 11);
 636
 637       assert(r_size >= 0);
 638       if (r_size && motion_code) {
 639          int residual = vl_vlc_get_uimsbf(&bs->vlc, r_size) + 1;
 640          delta[t] = ((abs(motion_code) - 1) << r_size) + residual;
 641          if (motion_code < 0)
 642             delta[t] = -delta[t];
 643       } else
 644          delta[t] = motion_code;
 645       if (dmv)
 646          dmvector[t] = vl_vlc_get_vlclbf(&bs->vlc, tbl_B11, 2);
 647    }
 648 }
 649
 650 static INLINE int
 651 wrap(short f, int shift)
 652 {
 653    if (f < (-16 << shift))
 654       return f + (32 << shift);
 655    else if (f >= 16 << shift)
 656       return f - (32 << shift);
 657    else
 658       return f;
 659 }
 660
 661 static INLINE void
 662 motion_vector_frame(struct vl_mpg12_bs *bs, int s, struct pipe_mpeg12_macroblock *mb)
 663 {
 664    int dmv = mb->macroblock_modes.bits.frame_motion_type == PIPE_MPEG12_MO_TYPE_DUAL_PRIME;
 665    short dmvector[2], delta[2];
 666
 667    if (mb->macroblock_modes.bits.frame_motion_type == PIPE_MPEG12_MO_TYPE_FIELD) {
 668       mb->motion_vertical_field_select |= vl_vlc_get_uimsbf(&bs->vlc, 1) << s;
 669       motion_vector(bs, 0, s, dmv, delta, dmvector);
 670       mb->PMV[0][s][0] = wrap(mb->PMV[0][s][0] + delta[0], bs->desc->f_code[s][0]);
 671       mb->PMV[0][s][1] = wrap(DIV2DOWN(mb->PMV[0][s][1]) + delta[1], bs->desc->f_code[s][1]) * 2;
 672
 673       mb->motion_vertical_field_select |= vl_vlc_get_uimsbf(&bs->vlc, 1) << (s + 2);
 674       motion_vector(bs, 1, s, dmv, delta, dmvector);
 675       mb->PMV[1][s][0] = wrap(mb->PMV[1][s][0] + delta[0], bs->desc->f_code[s][0]);
 676       mb->PMV[1][s][1] = wrap(DIV2DOWN(mb->PMV[1][s][1]) + delta[1], bs->desc->f_code[s][1]) * 2;
 677
 678    } else {
 679       motion_vector(bs, 0, s, dmv, delta, dmvector);
 680       mb->PMV[0][s][0] = wrap(mb->PMV[0][s][0] + delta[0], bs->desc->f_code[s][0]);
 681       mb->PMV[0][s][1] = wrap(mb->PMV[0][s][1] + delta[1], bs->desc->f_code[s][1]);
 682    }
 683 }
 684
 685 static INLINE void
 686 motion_vector_field(struct vl_mpg12_bs *bs, int s, struct pipe_mpeg12_macroblock *mb)
 687 {
 688    int dmv = mb->macroblock_modes.bits.field_motion_type == PIPE_MPEG12_MO_TYPE_DUAL_PRIME;
 689    short dmvector[2], delta[2];
 690
 691    if (mb->macroblock_modes.bits.field_motion_type == PIPE_MPEG12_MO_TYPE_16x8) {
 692       mb->motion_vertical_field_select |= vl_vlc_get_uimsbf(&bs->vlc, 1) << s;
 693       motion_vector(bs, 0, s, dmv, delta, dmvector);
 694
 695       mb->motion_vertical_field_select |= vl_vlc_get_uimsbf(&bs->vlc, 1) << (s + 2);
 696       motion_vector(bs, 1, s, dmv, delta, dmvector);
 697    } else {
 698       if (!dmv)
 699          mb->motion_vertical_field_select |= vl_vlc_get_uimsbf(&bs->vlc, 1) << s;
 700       motion_vector(bs, 0, s, dmv, delta, dmvector);
 701    }
 702 }
 703
 704 static INLINE void
 705 reset_predictor(struct vl_mpg12_bs *bs) {
 706    bs->pred_dc[0] = bs->pred_dc[1] = bs->pred_dc[2] = 0;
 707 }
 708
 709 static INLINE void
 710 decode_dct(struct vl_mpg12_bs *bs, struct pipe_mpeg12_macroblock *mb, int scale)
 711 {
 712    static const unsigned blk2cc[] = { 0, 0, 0, 0, 1, 2 };
 713    static const struct vl_vlc_entry *blk2dcsize[] = {
 714       tbl_B12, tbl_B12, tbl_B12, tbl_B12, tbl_B13, tbl_B13
 715    };
 716
 717    bool intra = mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA;
 718    const struct dct_coeff *table = intra ? bs->intra_dct_tbl : tbl_B14_AC;
 719    const struct dct_coeff *entry;
 720    int i, cbp, blk = 0;
 721    short *dst = mb->blocks;
 722
 723    vl_vlc_fillbits(&bs->vlc);
 724    mb->coded_block_pattern = cbp = intra ? 0x3F : vl_vlc_get_vlclbf(&bs->vlc, tbl_B9, 9);
 725
 726    goto entry;
 727
 728    while(1) {
 729       vl_vlc_eatbits(&bs->vlc, entry->length);
 730       if (entry->run == dct_End_of_Block) {
 731
 732 next_d:
 733          dst += 64;
 734          cbp <<= 1;
 735          cbp &= 0x3F;
 736          blk++;
 737
 738 entry:
 739          if (!cbp)
 740             break;
 741
 742          while(!(cbp & 0x20)) {
 743             cbp <<= 1;
 744             blk++;
 745          }
 746
 747          vl_vlc_fillbits(&bs->vlc);
 748
 749          if (intra) {
 750             unsigned cc = blk2cc[blk];
 751             unsigned size = vl_vlc_get_vlclbf(&bs->vlc, blk2dcsize[blk], 10);
 752
 753             if (size) {
 754                int dct_diff = vl_vlc_get_uimsbf(&bs->vlc, size);
 755                int half_range = 1 << (size - 1);
 756                if (dct_diff < half_range)
 757                   dct_diff = (dct_diff + 1) - (2 * half_range);
 758                bs->pred_dc[cc] += dct_diff;
 759             }
 760
 761             dst[0] = bs->pred_dc[cc];
 762             i = 0;
 763
 764             if (bs->desc->picture_coding_type == PIPE_MPEG12_PICTURE_CODING_TYPE_D)
 765                goto next_d;
 766          } else {
 767             entry = tbl_B14_DC + vl_vlc_peekbits(&bs->vlc, 17);
 768             i = -1;
 769             continue;
 770          }
 771
 772       } else if (entry->run == dct_Escape &&
 773                  bs->decoder->profile == PIPE_VIDEO_PROFILE_MPEG1) {
 774          i += vl_vlc_get_uimsbf(&bs->vlc, 6) + 1;
 775          if (i > 64)
 776             break;
 777
 778          dst[i] = vl_vlc_get_simsbf(&bs->vlc, 8);
 779          if (dst[i] == -128)
 780             dst[i] = vl_vlc_get_uimsbf(&bs->vlc, 8) - 256;
 781          else if (dst[i] == 0)
 782             dst[i] = vl_vlc_get_uimsbf(&bs->vlc, 8);
 783
 784          dst[i] *= scale;
 785       } else if (entry->run == dct_Escape) {
 786          i += vl_vlc_get_uimsbf(&bs->vlc, 6) + 1;
 787          if (i > 64)
 788             break;
 789
 790          dst[i] = vl_vlc_get_simsbf(&bs->vlc, 12) * scale;
 791
 792       } else {
 793          i += entry->run;
 794          if (i > 64)
 795             break;
 796
 797          dst[i] = entry->level * scale;
 798       }
 799
 800       vl_vlc_fillbits(&bs->vlc);
 801       entry = table + vl_vlc_peekbits(&bs->vlc, 17);
 802    }
 803
 804    if (bs->desc->picture_coding_type == PIPE_MPEG12_PICTURE_CODING_TYPE_D)
 805       vl_vlc_eatbits(&bs->vlc, 1);
 806 }
 807
 808 static INLINE void
 809 decode_slice(struct vl_mpg12_bs *bs, struct pipe_video_buffer *target)
 810 {
 811    struct pipe_mpeg12_macroblock mb;
 812    short dct_blocks[64*6];
 813    unsigned dct_scale;
 814    signed x = -1;
 815
 816    memset(&mb, 0, sizeof(mb));
 817    mb.base.codec = PIPE_VIDEO_FORMAT_MPEG12;
 818    mb.y = vl_vlc_get_uimsbf(&bs->vlc, 8) - 1;
 819    mb.blocks = dct_blocks;
 820
 821    reset_predictor(bs);
 822    vl_vlc_fillbits(&bs->vlc);
 823    dct_scale = quant_scale[bs->desc->q_scale_type][vl_vlc_get_uimsbf(&bs->vlc, 5)];
 824
 825    if (vl_vlc_get_uimsbf(&bs->vlc, 1))
 826       while (vl_vlc_get_uimsbf(&bs->vlc, 9) & 1)
 827          vl_vlc_fillbits(&bs->vlc);
 828
 829    vl_vlc_fillbits(&bs->vlc);
 830    assert(vl_vlc_peekbits(&bs->vlc, 23));
 831    do {
 832       int inc = 0;
 833
 834       while (1) {
 835          /* MPEG-1 macroblock stuffing, can appear an arbitrary number of times. */
 836          while (vl_vlc_peekbits(&bs->vlc, 11) == 15) {
 837             vl_vlc_eatbits(&bs->vlc, 11);
 838             vl_vlc_fillbits(&bs->vlc);
 839          }
 840
 841          if (vl_vlc_peekbits(&bs->vlc, 11) == 8) {
 842             vl_vlc_eatbits(&bs->vlc, 11);
 843             vl_vlc_fillbits(&bs->vlc);
 844             inc += 33;
 845          } else {
 846             inc += vl_vlc_get_vlclbf(&bs->vlc, tbl_B1, 11);
 847             break;
 848          }
 849       }
 850
 851       if (x != -1) {
 852          if (!inc)
 853             return;
 854          mb.num_skipped_macroblocks = inc - 1;
 855          bs->decoder->decode_macroblock(bs->decoder, target, &bs->desc->base, &mb.base, 1);
 856       }
 857       mb.x = x += inc;
 858       if (bs->decoder->profile == PIPE_VIDEO_PROFILE_MPEG1) {
 859          int width = align(bs->decoder->width, 16) / 16;
 860          mb.y += mb.x / width;
 861          mb.x = x %= width;
 862       }
 863
 864       switch (bs->desc->picture_coding_type) {
 865       case PIPE_MPEG12_PICTURE_CODING_TYPE_I:
 866          mb.macroblock_type = vl_vlc_get_vlclbf(&bs->vlc, tbl_B2, 2);
 867          break;
 868
 869       case PIPE_MPEG12_PICTURE_CODING_TYPE_P:
 870          mb.macroblock_type = vl_vlc_get_vlclbf(&bs->vlc, tbl_B3, 6);
 871          break;
 872
 873       case PIPE_MPEG12_PICTURE_CODING_TYPE_B:
 874          mb.macroblock_type = vl_vlc_get_vlclbf(&bs->vlc, tbl_B4, 6);
 875          break;
 876
 877       case PIPE_MPEG12_PICTURE_CODING_TYPE_D:
 878          vl_vlc_eatbits(&bs->vlc, 1);
 879          mb.macroblock_type = PIPE_MPEG12_MB_TYPE_INTRA;
 880          break;
 881       }
 882
 883       mb.macroblock_modes.value = 0;
 884       if (mb.macroblock_type & (PIPE_MPEG12_MB_TYPE_MOTION_FORWARD | PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD)) {
 885          if (bs->desc->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME) {
 886             if (bs->desc->frame_pred_frame_dct == 0)
 887                mb.macroblock_modes.bits.frame_motion_type = vl_vlc_get_uimsbf(&bs->vlc, 2);
 888             else
 889                mb.macroblock_modes.bits.frame_motion_type = 2;
 890          } else
 891             mb.macroblock_modes.bits.field_motion_type = vl_vlc_get_uimsbf(&bs->vlc, 2);
 892
 893       } else if ((mb.macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA) && bs->desc->concealment_motion_vectors) {
 894          if (bs->desc->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME)
 895             mb.macroblock_modes.bits.frame_motion_type = 2;
 896          else
 897             mb.macroblock_modes.bits.field_motion_type = 1;
 898       }
 899
 900       if (bs->desc->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME &&
 901           bs->desc->frame_pred_frame_dct == 0 &&
 902           mb.macroblock_type & (PIPE_MPEG12_MB_TYPE_INTRA | PIPE_MPEG12_MB_TYPE_PATTERN))
 903          mb.macroblock_modes.bits.dct_type = vl_vlc_get_uimsbf(&bs->vlc, 1);
 904
 905       if (mb.macroblock_type & PIPE_MPEG12_MB_TYPE_QUANT)
 906          dct_scale = quant_scale[bs->desc->q_scale_type][vl_vlc_get_uimsbf(&bs->vlc, 5)];
 907
 908       if (inc > 1 && bs->desc->picture_coding_type == PIPE_MPEG12_PICTURE_CODING_TYPE_P)
 909          memset(mb.PMV, 0, sizeof(mb.PMV));
 910
 911       mb.motion_vertical_field_select = 0;
 912       if ((mb.macroblock_type & PIPE_MPEG12_MB_TYPE_MOTION_FORWARD) ||
 913           (mb.macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA && bs->desc->concealment_motion_vectors)) {
 914          if (bs->desc->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME)
 915             motion_vector_frame(bs, 0, &mb);
 916          else
 917             motion_vector_field(bs, 0, &mb);
 918       }
 919
 920       if (mb.macroblock_type & PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD) {
 921          if (bs->desc->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME)
 922             motion_vector_frame(bs, 1, &mb);
 923          else
 924             motion_vector_field(bs, 1, &mb);
 925       }
 926
 927       if (mb.macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA && bs->desc->concealment_motion_vectors) {
 928          unsigned extra = vl_vlc_get_uimsbf(&bs->vlc, 1);
 929          mb.PMV[1][0][0] = mb.PMV[0][0][0];
 930          mb.PMV[1][0][1] = mb.PMV[0][0][1];
 931          assert(extra);
 932       } else if (mb.macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA ||
 933                 !(mb.macroblock_type & (PIPE_MPEG12_MB_TYPE_MOTION_FORWARD |
 934                                         PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD))) {
 935          memset(mb.PMV, 0, sizeof(mb.PMV));
 936       }
 937
 938       if ((mb.macroblock_type & PIPE_MPEG12_MB_TYPE_MOTION_FORWARD &&
 939            mb.macroblock_modes.bits.frame_motion_type == 2) ||
 940           (mb.macroblock_modes.bits.frame_motion_type == 3)) {
 941             mb.PMV[1][0][0] = mb.PMV[0][0][0];
 942             mb.PMV[1][0][1] = mb.PMV[0][0][1];
 943       }
 944
 945       if (mb.macroblock_type & PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD &&
 946           mb.macroblock_modes.bits.frame_motion_type == 2) {
 947             mb.PMV[1][1][0] = mb.PMV[0][1][0];
 948             mb.PMV[1][1][1] = mb.PMV[0][1][1];
 949       }
 950
 951       if (inc > 1 || !(mb.macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA))
 952          reset_predictor(bs);
 953
 954       if (mb.macroblock_type & (PIPE_MPEG12_MB_TYPE_INTRA | PIPE_MPEG12_MB_TYPE_PATTERN)) {
 955          memset(dct_blocks, 0, sizeof(dct_blocks));
 956          decode_dct(bs, &mb, dct_scale);
 957       } else
 958          mb.coded_block_pattern = 0;
 959
 960       vl_vlc_fillbits(&bs->vlc);
 961    } while (vl_vlc_bits_left(&bs->vlc) && vl_vlc_peekbits(&bs->vlc, 23));
 962
 963    mb.num_skipped_macroblocks = 0;
 964    bs->decoder->decode_macroblock(bs->decoder, target, &bs->desc->base, &mb.base, 1);
 965 }
 966
 967 void
 968 vl_mpg12_bs_init(struct vl_mpg12_bs *bs, struct pipe_video_codec *decoder)
 969 {
 970    static bool tables_initialized = false;
 971
 972    assert(bs);
 973
 974    memset(bs, 0, sizeof(struct vl_mpg12_bs));
 975
 976    bs->decoder = decoder;
 977
 978    if (!tables_initialized) {
 979       init_tables();
 980       tables_initialized = true;
 981    }
 982 }
 983
 984 void
 985 vl_mpg12_bs_decode(struct vl_mpg12_bs *bs,
 986                    struct pipe_video_buffer *target,
 987                    struct pipe_mpeg12_picture_desc *picture,
 988                    unsigned num_buffers,
 989                    const void * const *buffers,
 990                    const unsigned *sizes)
 991 {
 992    assert(bs);
 993
 994    bs->desc = picture;
 995    bs->intra_dct_tbl = picture->intra_vlc_format ? tbl_B15 : tbl_B14_AC;
 996
 997    vl_vlc_init(&bs->vlc, num_buffers, buffers, sizes);
 998    while (vl_vlc_search_byte(&bs->vlc, ~0, 0x00) && vl_vlc_bits_left(&bs->vlc) > 32) {
 999       uint32_t code = vl_vlc_peekbits(&bs->vlc, 32);
1000
1001       if (code >= 0x101 && code <= 0x1AF) {
1002          vl_vlc_eatbits(&bs->vlc, 24);
1003          decode_slice(bs, target);
1004
1005          /* align to a byte again */
1006          vl_vlc_eatbits(&bs->vlc, vl_vlc_valid_bits(&bs->vlc) & 7);
1007
1008       } else {
1009          vl_vlc_eatbits(&bs->vlc, 8);
1010       }
1011
1012       vl_vlc_fillbits(&bs->vlc);
1013    }
1014 }