git.sesse.net Git - vlc/blob - src/video_parser/vpar_blocks.c

   1 /*****************************************************************************
   2  * vpar_blocks.c : blocks parsing
   3  * (c)1999 VideoLAN
   4  *****************************************************************************/
   5
   6 /*****************************************************************************
   7  * Preamble
   8  *****************************************************************************/
   9 #include <errno.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <unistd.h>
  13 #include <string.h>
  14 #include <sys/uio.h>
  15 #include <X11/Xlib.h>
  16 #include <X11/extensions/XShm.h>
  17
  18 #include "config.h"
  19 #include "common.h"
  20 #include "mtime.h"
  21 #include "vlc_thread.h"
  22
  23 #include "intf_msg.h"
  24 #include "debug.h"                    /* ?? temporaire, requis par netlist.h */
  25
  26 #include "input.h"
  27 #include "input_netlist.h"
  28 #include "decoder_fifo.h"
  29 #include "video.h"
  30 #include "video_output.h"
  31
  32 #include "vdec_idct.h"
  33 #include "video_decoder.h"
  34 #include "vdec_motion.h"
  35
  36 #include "vpar_blocks.h"
  37 #include "vpar_headers.h"
  38 #include "video_fifo.h"
  39 #include "vpar_synchro.h"
  40 #include "video_parser.h"
  41
  42 /*
  43  * Local prototypes
  44  */
  45 static __inline__ void InitMacroblock( vpar_thread_t * p_vpar,
  46                                        macroblock_t * p_mb );
  47 static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar );
  48 static __inline__ void MacroblockModes( vpar_thread_t * p_vpar,
  49                                         macroblock_t * p_mb );
  50 typedef (void *)    f_decode_block_t( vpar_thread_t *, macroblock_t *, int );
  51 static void vpar_DecodeMPEG1Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
  52 static void vpar_DecodeMPEG1Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
  53 static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
  54 static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
  55
  56 /*
  57  * Standard variables
  58  */
  59
  60 /*****************************************************************************
  61  * pi_default_intra_quant : default quantization matrix
  62  *****************************************************************************/
  63 #ifndef VDEC_DFT
  64 extern int pi_default_intra_quant =
  65 {
  66     8,  16, 19, 22, 26, 27, 29, 34,
  67     16, 16, 22, 24, 27, 29, 34, 37,
  68     19, 22, 26, 27, 29, 34, 34, 38,
  69     22, 22, 26, 27, 29, 34, 37, 40,
  70     22, 26, 27, 29, 32, 35, 40, 48,
  71     26, 27, 29, 32, 35, 40, 48, 58,
  72     26, 27, 29, 34, 38, 46, 56, 69,
  73     27, 29, 35, 38, 46, 56, 69, 83
  74 }:
  75 #else
  76 extern int pi_default_intra_quant =
  77 {
  78     2048,   5681,   6355,   6623,   6656,   5431,   4018,   2401,
  79     5681,   7880,   10207,  10021,  9587,   8091,   6534,   3625,
  80     6355,   10207,  11363,  10619,  9700,   8935,   6155,   3507,
  81     6623,   9186,   10226,  9557,   8730,   8041,   6028,   3322,
  82     5632,   9232,   9031,   8730,   8192,   7040,   5542,   3390,
  83     5230,   7533,   7621,   7568,   7040,   6321,   5225,   3219,
  84     3602,   5189,   5250,   5539,   5265,   5007,   4199,   2638,
  85     1907,   2841,   3230,   3156,   3249,   3108,   2638,   1617
  86 };
  87 #endif
  88
  89 /*****************************************************************************
  90  * pi_default_nonintra_quant : default quantization matrix
  91  *****************************************************************************/
  92 #ifndef VDEC_DFT
  93 extern int pi_default_nonintra_quant =
  94 {
  95     16, 16, 16, 16, 16, 16, 16, 16,
  96     16, 16, 16, 16, 16, 16, 16, 16,
  97     16, 16, 16, 16, 16, 16, 16, 16,
  98     16, 16, 16, 16, 16, 16, 16, 16,
  99     16, 16, 16, 16, 16, 16, 16, 16,
 100     16, 16, 16, 16, 16, 16, 16, 16,
 101     16, 16, 16, 16, 16, 16, 16, 16,
 102     16, 16, 16, 16, 16, 16, 16, 16
 103 };
 104 #else
 105 extern int pi_default_nonintra_quant =
 106 {
 107     4096,   5680,   5344,   4816,   4096,   3216,   2224,   1136,
 108     5680,   7888,   7424,   6688,   5680,   4464,   3072,   1568,
 109     5344,   7424,   6992,   6288,   5344,   4208,   2896,   1472,
 110     4816,   6688,   6288,   5664,   4816,   3792,   2608,   1328,
 111     4096,   5680,   5344,   4816,   4096,   3216,   2224,   1136,
 112     3216,   4464,   4208,   3792,   3216,   2528,   1744,   880,
 113     2224,   3072,   2896,   2608,   2224,   1744,   1200,   608,
 114     1136,   1568,   1472,   1328,   1136,   880,    608,    304
 115 };
 116 #endif
 117
 118 /*****************************************************************************
 119  * pi_scan : zig-zag and alternate scan patterns
 120  *****************************************************************************/
 121 extern int pi_scan[2][64] =
 122 {
 123     { /* Zig-Zag pattern */
 124         0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
 125         12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
 126         35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
 127         58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
 128     },
 129     { /* Alternate scan pattern */
 130         0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
 131         41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
 132         51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
 133         53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
 134     }
 135 };
 136
 137 /*
 138  * Initialization of lookup tables
 139  */
 140
 141 /*****************************************************************************
 142  * vpar_InitCrop : Initialize the crop table for saturation
 143  *                 (ISO/IEC 13818-2 section 7.4.3)
 144  *****************************************************************************/
 145 #if defined(MPEG2_COMPLIANT) && !defined(VDEC_DFT)
 146 void vpar_InitCrop( vpar_thread_t * p_vpar )
 147 {
 148     int i_dummy;
 149
 150     p_vpar->pi_crop = p_vpar->pi_crop_buf + 32768;
 151
 152     for( i_dummy = -32768; i_dummy < -2048; i_dummy++ )
 153     {
 154         p_vpar->pi_crop[i_dummy] = -2048;
 155     }
 156     for( ; i_dummy < 2047; i_dummy++ )
 157     {
 158         p_vpar->pi_crop[i_dummy] = i_dummy;
 159     }
 160     for( ; i_dummy < 32767; i_dummy++ )
 161     {
 162         p_vpar->pi_crop[i_dummy] = 2047;
 163     }
 164 }
 165 #endif
 166
 167 /*****************************************************************************
 168  * InitMbAddrInc : Initialize the lookup table for mb_addr_inc               *
 169  *****************************************************************************/
 170
 171 /* Fonction for filling up the lookup table for mb_addr_inc */
 172 void __inline__ FillMbAddrIncTable( vpar_thread_t * p_vpar,
 173                                     int i_start, int i_end, int i_step,
 174                                     int * pi_value, int i_length )
 175 {
 176     int i_dummy, i_dummy2;
 177     for( i_dummy = i_start, i_dummy < i_end, i_dummy += i_step )
 178         for( i_dummy2 = 0, i_dummy2 < i_step, i_dummy2 ++ )
 179         {
 180             p_vpar->pl_mb_addr_inc[i_dummy + i_dummy2].value = * pi_value;
 181             p_vpar->pl_mb_addr_inc[i_dummy + i_dummy2].length = i_length;
 182         }
 183     i_value --;
 184 }
 185
 186 /* Fonction that initialize the table using the last one */
 187 void InitMbAddrInc( vpar_thread_t * p_vpar )
 188 {
 189     int i_dummy;
 190     int *  pi_value;
 191     for (i_dummy = 0; i_dummy < 8; i_dummy++)
 192     {
 193         p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR;
 194         p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0;
 195     }
 196
 197     p_vpar->pl_mb_addr_inc[8].i_value = MB_ADDRINC_ESCAPE;
 198     p_vpar->pl_mb_addr_inc[8].i_length = 11;
 199
 200     for (i_dummy = 9; i_dummy < 15; i_dummy ++)
 201     {
 202         p_vpar->pl_mb_addr_inc[i_dummy].i_value =  MB_ERROR;
 203         p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0;
 204     }
 205
 206     p_vpar->pl_mb_addr_inc[15].i_value = MB_ADDRINC_STUFFING;
 207     p_vpar->pl_mb_addr_inc[15].i_length = 11;
 208
 209     for (i = 16; i < 24; i++)
 210     {
 211         p_vpar->pl_mb_addr_inc[i_dummy].i_value =  MB_ERROR;
 212         p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0;
 213     }
 214     pi_value = (int *) malloc( sizeof( int ) );
 215     * pi_value = 33;
 216     FillMbAddrIncTable( p_vpar, 1024, 2048, 1024, pi_value, 1 );
 217     FillMbAddrIncTable( p_vpar, 512, 1024, 256, pi_value, 3 );
 218     FillMbAddrIncTable( p_vpar, 256, 512, 128, pi_value, 4 );
 219     FillMbAddrIncTable( p_vpar, 128, 256, 64, pi_value, 5 );
 220     FillMbAddrIncTable( p_vpar, 96, 128, 16, pi_value, 7 );
 221     FillMbAddrIncTable( p_vpar, 48, 96, 8, pi_value, 8 );
 222     FillMbAddrIncTable( p_vpar, 36, 48, 2, pi_value, 10 );
 223     FillMbAddrIncTable( p_vpar, 24, 36, 1, pi_value, 11 );
 224 }
 225 /*****************************************************************************
 226  * InitDCT : Initialize tables giving the length of the dct coefficient
 227  *           from the vlc code
 228  *****************************************************************************/
 229
 230 void InitDCTTables( vpar_thread_t * p_vpar )
 231 {
 232     /* Tables are cut in two parts to reduce memory occupation */
 233
 234     /* Table B-12, dct_dc_size_luminance, codes 00xxx ... 11110 */
 235     p_vpar->pppl_dct_dc_size[0][0] =
 236     { {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
 237       {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
 238       {0, 3}, {0, 3}, {0, 3}, {0, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3},
 239       {4, 3}, {4, 3}, {4, 3}, {4, 3}, {5, 4}, {5, 4}, {6, 5}, {MB_ERROR, 0}
 240     };
 241
 242     /* Table B-12, dct_dc_size_luminance, codes 111110xxx ... 111111111 */
 243     p_vpar->pppl_dct_dc_lum_size[1][0] =
 244     { {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6},
 245       {8, 7}, {8, 7}, {8, 7}, {8, 7}, {9, 8}, {9, 8}, {10,9}, {11,9}
 246       {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0},
 247       {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0},
 248       {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0},
 249       {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}
 250     };
 251
 252     /* Table B-13, dct_dc_size_chrominance, codes 00xxx ... 11110 */
 253     p_vpar->pppl_dct_dc_chrom_size[0][1] =
 254     { {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2},
 255       {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
 256       {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
 257       {3, 3}, {3, 3}, {3, 3}, {3, 3}, {4, 4}, {4, 4}, {5, 5}, {MB_ERROR, 0}
 258     };
 259
 260     /* Table B-13, dct_dc_size_chrominance, codes 111110xxxx ... 1111111111 */
 261     p_vpar->pppl_dct_dc_size[1][1] =
 262     { {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
 263       {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
 264       {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7},
 265       {8, 8}, {8, 8}, {8, 8}, {8, 8}, {9, 9}, {9, 9}, {10,10}, {11,10}
 266     };
 267
 268 }
 269
 270 /*****************************************************************************
 271  * Init*MBType : Initialize lookup table for the Macroblock type             *
 272  * ***************************************************************************/
 273
 274 /* Fonction for filling up the tables */
 275 static void __inline__ FillMBType( vpar_thread_t * p_vpar,
 276                                    int           i_mb_type,
 277                                    int           i_start,
 278                                    int           i_end,
 279                                    int           i_value,
 280                                    int           i_length )
 281 {
 282     int i_dummy;
 283     for( i_dummy = i_start, i_dummy < i_end, i++ )
 284     {
 285         p_vpar->pm_mb_type[i_mb_type][i_dummy].i_value = i_value;
 286         p_vpar->pm_mb_type[i_mb_type][i_dummy].i_length = i_length;
 287     }
 288 }
 289
 290 /* Fonction that fills the table for P MB_Type */
 291 void InitPMBType( vpar_thread_t * p_vpar )
 292 {
 293     FillMBType( p_vpar, 0, 32, 64, MB_MOTION_FORWARD|MB_PATTERN, 1 );
 294     FillMBType( p_vpar, 0, 16, 32, MB_PATTERN, 2 );
 295     FillMBType( p_vpar, 0, 8, 16, MB_MOTION_FORWARD, 3 );
 296     FillMBType( p_vpar, 0, 6, 8, MB_INTRA, 5 );
 297     FillMBType( p_vpar, 0, 4, 6, MB_QUANT|MB_MOTION_FORWARD|PATTERN, 5 );
 298     FillMBType( p_vpar, 0, 2, 4, MB_QUANT|MB_PATTERN, 5 );
 299     p_vpar->pm_mb_type[0][1].i_value = MB_QUANT|MB_INTRA;
 300     p_vpar->pm_mb_type[0][1].i_length = 6;
 301     p_vpar->pm_mb_type[0][0].i_value = MB_ERROR;
 302     p_vpar->pm_mb_type[0][0].i_length = 0;
 303 }
 304
 305 /* Fonction that fills the table for B MB_Type */
 306 void InitBMBType( vpar_thread_t * p_vpar )
 307 {
 308     FillMBType( p_vpar, 1, 48, 64, MB_MOTION_FORWARD
 309                                   |MB_MOTION_BACKWARD|MB_PATTERN, 2 );
 310     FillMBType( p_vpar, 1, 32, 48, MB_MOTION_FORWARD|MB_MOTION_BACKWARD, 2 );
 311     FillMBType( p_vpar, 1, 24, 32, MB_MOTION_BACKWARD|MB_PATTERN, 3 );
 312     FillMBType( p_vpar, 1, 16, 24, MB_MOTION_BACKWARD, 3 );
 313     FillMBType( p_vpar, 1, 12, 16, MB_MOTION_FORWARD|MB_PATTERN, 4 );
 314     FillMBType( p_vpar, 1, 8, 12, MB_MOTION_FORWARD, 4 );
 315     FillMBType( p_vpar, 1, 6, 8, MB_INTRA, 5 );
 316     FillMBType( p_vpar, 1, 4, 6, MB_QUANT|MB_MOTION_FORWARD
 317                                 |MB_MOTION_BACKWARD|MB_PATTERN, 5 );
 318     p_vpar->pm_mb_type[1][3].i_value = MB_QUANT|MB_MOTION_FORWARD|MB_PATTERN
 319     p_vpar->pm_mb_type[1][3].i_length = 6;
 320     p_vpar->pm_mb_type[1][2].i_value = MB_QUANT|MB_MOTION_BACKWARD|MB_PATTERN;
 321     p_vpar->pm_mb_type[1][2].i_length = 6;
 322     p_vpar->pm_mb_type[1][1].i_value = MB_QUANT|MB_INTRA;
 323     p_vpar->pm_mb_type[1][1].i_length = 6;
 324     p_vpar->pm_mb_type[1][0].i_value =MB_ERROR;
 325     p_vpar->pm_mb_type[1][0].i_length = 0;
 326 }
 327
 328 /*****************************************************************************
 329  * InitCodedPattern : Initialize the lookup table for decoding
 330  *                    coded block pattern
 331  *****************************************************************************/
 332 void InitCodedPattern( vpar_thread_t * p_vpar )
 333 {
 334     p_vpar->pl_coded_pattern =
 335     { {(unsigned int)ERROR, 0}, {(unsigned int)ERROR, 0}, {39, 9}, {27, 9}, {59, 9}, {55, 9}, {47, 9}, {31, 9},
 336     {58, 8}, {58, 8}, {54, 8}, {54, 8}, {46, 8}, {46, 8}, {30, 8}, {30, 8},
 337     {57, 8}, {57, 8}, {53, 8}, {53, 8}, {45, 8}, {45, 8}, {29, 8}, {29, 8},
 338     {38, 8}, {38, 8}, {26, 8}, {26, 8}, {37, 8}, {37, 8}, {25, 8}, {25, 8},
 339     {43, 8}, {43, 8}, {23, 8}, {23, 8}, {51, 8}, {51, 8}, {15, 8}, {15, 8},
 340     {42, 8}, {42, 8}, {22, 8}, {22, 8}, {50, 8}, {50, 8}, {14, 8}, {14, 8},
 341     {41, 8}, {41, 8}, {21, 8}, {21, 8}, {49, 8}, {49, 8}, {13, 8}, {13, 8},
 342     {35, 8}, {35, 8}, {19, 8}, {19, 8}, {11, 8}, {11, 8}, {7, 8}, {7, 8},
 343     {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
 344     {10, 7}, {10, 7}, {10, 7}, {10, 7}, {6, 7}, {6, 7}, {6, 7}, {6, 7},
 345     {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
 346     {9, 7}, {9, 7}, {9, 7}, {9, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7},
 347     {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6},
 348     {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6},
 349     {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6},
 350     {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6},
 351     {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
 352     {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
 353     {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5},
 354     {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5},
 355     {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5},
 356     {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5},
 357     {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5},
 358     {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5},
 359     {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5},
 360     {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5},
 361     {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5},
 362     {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5},
 363     {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5},
 364     {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5},
 365     {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5},
 366     {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5},
 367     {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5},
 368     {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5},
 369     {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5},
 370     {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5},
 371     {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5},
 372     {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5},
 373     {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5},
 374     {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5},
 375     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
 376     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
 377     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
 378     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
 379     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
 380     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
 381     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
 382     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
 383     {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
 384     {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
 385     {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
 386     {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
 387     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
 388     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
 389     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
 390     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
 391     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
 392     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
 393     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
 394     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
 395     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
 396     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
 397     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
 398     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3} };
 399 }
 400
 401 /*
 402  * Macroblock parsing functions
 403  */
 404
 405 /*****************************************************************************
 406  * vpar_ParseMacroblock : Parse the next macroblock
 407  *****************************************************************************/
 408 void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address,
 409                            int i_mb_previous, int i_mb_base )
 410 {
 411     static f_addb_t ppf_addb_intra[2] = {vdec_AddBlock, vdec_CopyBlock};
 412     static f_decode_block_t pppf_decode_block[2][2] =
 413                 { {vpar_DecodeMPEG1Non, vpar_DecodeMPEG1Intra},
 414                   {vpar_DecodeMPEG2Non, vpar_DecodeMPEG2Intra} };
 415     static int      pi_x[12] = {0,8,0,8,0,0,0,0,8,8,8,8};
 416     static int      pi_y[2][12] = { {0,0,8,8,0,0,8,8,0,0,8,8},
 417                                     {0,0,1,1,0,0,1,1,0,0,1,1} };
 418     static int      pi_chroma_hor[4] = { 0, 1, 1, 0 };
 419     static int      pi_chroma_ver[4] = { 0, 1, 0, 0 };
 420
 421     int             i_mb, i_b, i_mask;
 422     macroblock_t *  p_mb;
 423     f_addb_t        pf_addb;
 424     elem_t *        p_data1;
 425     elem_t *        p_data2;
 426
 427     *pi_mb_address += MacroblockAddressIncrement( p_vpar );
 428
 429     for( i_mb = i_mb_previous; i_mb < *pi_mb_address; i_mb++ )
 430     {
 431         /* Skipped macroblock (ISO/IEC 13818-2 7.6.6). */
 432         static int          pi_dc_dct_reinit[4] = {128,256,512,1024};
 433         static f_motion_t   pf_motion_skipped[4] = {NULL, vdec_MotionField,
 434                                 vdec_MotionField, vdec_MotionFrame};
 435
 436         /* Reset DC predictors (7.2.1). */
 437         p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
 438             = p_vpar->slice.pi_dc_dct_pred[2]
 439             = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
 440
 441         if( p_vpar->picture.i_coding_type == P_CODING_TYPE )
 442         {
 443             /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
 444             bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
 445         }
 446
 447         if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + i_mb] =
 448              vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
 449         {
 450             p_vpar->picture.b_error = 1;
 451             intf_ErrMsg("vpar error: macroblock list is empty !");
 452             return;
 453         }
 454
 455         InitMacroblock( p_vpar, p_mb );
 456
 457         /* No IDCT nor AddBlock. */
 458         for( i_b = 0; i_b < 12; i_b++ )
 459         {
 460             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 461             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 462         }
 463
 464         /* Motion type is picture structure. */
 465         p_mb->pf_motion = pf_motion_skipped[p_vpar->picture.i_structure];
 466
 467         /* Predict from field of same parity. */
 468         /* ??? */
 469     }
 470
 471     /* Get a macroblock structure. */
 472     if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + *pi_mb_address] =
 473          vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
 474     {
 475         p_vpar->picture.b_error = 1;
 476         intf_ErrMsg("vpar error: macroblock list is empty !");
 477         return;
 478     }
 479
 480     InitMacroblock( p_vpar, p_mb );
 481
 482     /* Parse off macroblock_modes structure. */
 483     MacroblockModes( p_vpar, p_mb );
 484
 485     if( p_vpar->mb.i_mb_type & MB_QUANT )
 486     {
 487         LoadQuantizerScale( p_vpar );
 488     }
 489
 490     if( p_vpar->mb.i_mb_type & MB_MOTION_FORWARD )
 491     {
 492         (*p_vpar->sequence.pf_decode_mv)( p_vpar, 0 );
 493     }
 494
 495     if( p_vpar->mb.i_mb_type & MB_MOTION_BACKWARD )
 496     {
 497         (*p_vpar->sequence.pf_decode_mv)( p_vpar, 1 );
 498     }
 499
 500     if( p_vpar->picture.b_concealment_mv && (p_vpar->mb.i_mb_type & MB_INTRA) )
 501     {
 502         DumpBits( &p_vpar->bit_stream, 1 );
 503     }
 504
 505     if( p_vpar->mb.i_mb_type & MB_PATTERN )
 506     {
 507         (*p_vpar->sequence.pf_decode_pattern)( p_vpar );
 508     }
 509     else
 510     {
 511         int     pi_coded_block_pattern[2] = {0,
 512                     (1 << 4+2*p_vpar->sequence.i_chroma_nb_blocks) - 1};
 513         p_vpar->mb.i_coded_block_pattern = pi_coded_block_pattern
 514                                     [p_vpar->mb.i_mb_type & MB_INTRA];
 515     }
 516
 517     pf_addb = ppf_addb_intra[p_vpar->mb.i_mb_type & MB_INTRA];
 518
 519     /*
 520      * Effectively decode blocks.
 521      */
 522
 523     i_mask = 1 << (3 + 2*p_vpar->sequence.i_chroma_nb_blocks);
 524
 525     /* luminance */
 526     p_data1 = p_mb->p_picture->p_y
 527               + p_mb->i_l_x + p_mb->i_l_y*(p_vpar->sequence.i_width);
 528
 529     for( i_b = 0; i_b < 4; i_b++, i_mask >>= 1 )
 530     {
 531         if( p_vpar->mb.i_coded_block_pattern & i_mask )
 532         {
 533             memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
 534             (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
 535                                [p_vpar->mb.i_mb_type & MB_INTRA])
 536                 ( p_vpar, p_mb, i_b );
 537
 538             /* decode_block has already set pf_idct and pi_sparse_pos. */
 539             p_mb->pf_addb[i_b] = pf_addb;
 540
 541             /* Calculate block coordinates. */
 542             p_mb->p_data[i_b] = p_data1
 543                                  + pi_y[p_vpar->mb.b_dct_type][i_b]
 544                                    * p_vpar->sequence.i_chroma_width;
 545         }
 546         else
 547         {
 548             /* Block not coded, so no IDCT, nor AddBlock */
 549             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 550             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 551         }
 552     }
 553
 554     /* chrominance U */
 555     p_data1 = p_mb->p_picture->p_u
 556               + p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]
 557               + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
 558                 * (p_vpar->sequence.i_chroma_width);
 559     p_data2 = p_mb->p_picture->p_v
 560               + p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]
 561               + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
 562                 * (p_vpar->sequence.i_chroma_width);
 563
 564     for( i_b = 4; i_b < 4 + 2*p_vpar->sequence.i_chroma_nb_blocks;
 565          i_b++, i_mask >>= 1 )
 566     {
 567         elem_t *    pp_data[2] = {p_data1, p_data2};
 568
 569         if( p_vpar->mb.i_coded_block_pattern & i_mask )
 570         {
 571             memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
 572             (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
 573                                [p_vpar->mb.i_mb_type & MB_INTRA])
 574                 ( p_vpar, p_mb, i_b );
 575
 576             /* decode_block has already set pf_idct and pi_sparse_pos. */
 577             p_mb->pf_addb[i_b] = pf_addb;
 578
 579             /* Calculate block coordinates. */
 580             p_mb->p_data[i_b] = pp_data[i_b & 1]
 581                                  + pi_y[p_vpar->mb.b_dct_type][i_b]
 582                                    * p_vpar->sequence.i_chroma_width;
 583         }
 584         else
 585         {
 586             /* Block not coded, so no IDCT, nor AddBlock */
 587             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 588             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 589         }
 590     }
 591
 592     if( !( p_vpar->mb.i_mb_type & MB_INTRA ) )
 593     {
 594         static int          pi_dc_dct_reinit[4] = {128,256,512,1024};
 595
 596         /* Reset DC predictors (7.2.1). */
 597         p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
 598             = p_vpar->slice.pi_dc_dct_pred[2]
 599             = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
 600     }
 601     else if( !p_vpar->picture.b_concealment_mv )
 602     {
 603         /* Reset MV predictors. */
 604         bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
 605     }
 606
 607     if( (p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
 608         !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD|MB_INTRA)) )
 609     {
 610         /* Special No-MC macroblock in P pictures (7.6.3.5). */
 611         p_vpar->slice.pppi_pmv[0][0][0] = p_vpar->slice.pppi_pmv[0][0][1] =
 612         p_vpar->slice.pppi_pmv[1][0][0] = p_vpar->slice.pppi_pmv[1][0][1] = 0;
 613
 614         /* motion type ?????? */
 615         /* predict from field of same parity ????? */
 616     }
 617 }
 618
 619 /*****************************************************************************
 620  * InitMacroblock : Initialize macroblock values
 621  *****************************************************************************/
 622 static __inline__ void InitMacroblock( vpar_thread_t * p_vpar,
 623                                        macroblock_t * p_mb )
 624 {
 625     p_mb->p_picture = p_vpar->picture.p_picture;
 626     p_mb->i_structure = p_vpar->picture.i_structure;
 627     p_mb->i_l_x = p_vpar->mb.i_l_x;
 628     p_mb->i_l_y = p_vpar->mb.i_l_y;
 629     p_mb->i_c_x = p_vpar->mb.i_c_x;
 630     p_mb->i_c_y = p_vpar->mb.i_c_y;
 631     p_mb->i_chroma_nb_blocks = p_vpar->sequence.i_chroma_nb_blocks;
 632
 633     p_mb->i_addb_l_stride = p_mb->i_l_stride = p_vpar->picture.i_l_stride;
 634     p_mb->i_addb_c_stride = p_mb->i_c_stride = p_vpar->picture.i_c_stride;
 635
 636     /* Update macroblock real position. */
 637     p_vpar->mb.i_l_x += 16;
 638     p_vpar->mb.i_l_y += (p_vpar->mb.i_l_x / p_vpar->sequence.i_width)
 639                         * (2 - p_vpar->picture.b_frame_structure) * 16;
 640     p_vpar->mb.i_l_x %= p_vpar->sequence.i_width;
 641
 642     p_vpar->mb.i_c_x += p_vpar->sequence.i_chroma_mb_width;
 643     p_vpar->mb.i_c_y += (p_vpar->mb.i_c_x / p_vpar->sequence.i_chroma_width)
 644                         * (2 - p_vpar->picture.b_frame_structure)
 645                         * p_vpar->sequence.i_chroma_mb_height;
 646     p_vpar->mb.i_c_x %= p_vpar->sequence.i_chroma_width;
 647 }
 648
 649 /*****************************************************************************
 650  * MacroblockAddressIncrement : Get the macroblock_address_increment field
 651  *****************************************************************************/
 652 static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar )
 653 {
 654     /* Index in the lookup table mb_addr_inc */
 655     int    i_index = ShowBits( &p_vpar->bit_stream, 11 );
 656     p_vpar->pl_mb.i_addr_inc = 0;
 657     /* Test the presence of the escape character */
 658     while( i_index == 8 )
 659     {
 660         DumpBits( &p_vpar->bit_stream, 11 );
 661         p_vpar->mb.i_addr_inc += 33;
 662         i_index = ShowBits( &p_vpar->bit_stream, 11 );
 663     }
 664     /* Affect the value from the lookup table */
 665     p_vpar->pl_mb.i_addr_inc += p_vpar->pl_mb_addr_inc[i_index].i_value;
 666     /* Dump the good number of bits */
 667     DumpBits( &p_vpar->bit_stream, p_vpar->pl_mb_addr_inc[i_index].i_length );
 668 }
 669
 670 /*****************************************************************************
 671  * MacroblockModes : Get the macroblock_modes structure
 672  *****************************************************************************/
 673 static __inline__ void MacroblockModes( vpar_thread_t * p_vpar,
 674                                         macroblock_t * p_mb )
 675 {
 676     static f_motion_t   pf_motion[2][4] =
 677         { {NULL, vdec_FieldRecon, vdec_16x8Recon, vdec_DMVRecon},
 678           {NULL, vdec_FieldRecon, vdec_FrameRecon, vdec_DMVRecon} };
 679     static int          ppi_mv_count[2][4] = { {0, 1, 2, 1}, {0, 2, 1, 1} };
 680     static int          ppi_mv_format[2][4] = { {0, 1, 1, 1}, {0, 1, 2, 1} };
 681
 682     /* Get macroblock_type. */
 683     p_vpar->mb.i_mb_type = (p_vpar->picture.pf_macroblock_type)
 684                                   ( vpar_thread_t * p_vpar );
 685
 686     /* SCALABILITY : warning, we don't know if spatial_temporal_weight_code
 687      * has to be dropped, take care if you use scalable streams. */
 688     /* DumpBits( &p_vpar->bit_stream, 2 ); */
 689
 690     if( !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD | MB_MOTION_BACKWARD))
 691         || p_vpar->picture.b_frame_pred_frame_dct )
 692     {
 693         /* If mb_type has neither MOTION_FORWARD nor MOTION_BACKWARD, this
 694          * is useless, but also harmless. */
 695         p_vpar->mb.i_motion_type = MOTION_FRAME;
 696     }
 697     else
 698     {
 699         p_vpar->mb.i_motion_type = GetBits( &p_vpar->bit_stream, 2 );
 700     }
 701
 702     p_mb->pf_motion = pf_motion[p_vpar->picture.b_frame_structure]
 703                               [p_vpar->mb.i_motion_type];
 704     p_vpar->mb.i_mv_count = ppi_mv_count[p_vpar->picture.b_frame_structure]
 705                                         [p_vpar->mb.i_motion_type];
 706     p_vpar->mb.i_mv_format = ppi_mv_format[p_vpar->picture.b_frame_structure]
 707                                           [p_vpar->mb.i_motion_type];
 708
 709     p_vpar->mb.b_dct_type = 0;
 710     if( (p_vpar->picture.i_structure == FRAME_STRUCTURE) &&
 711         (!p_vpar->picture.b_frame_pred_frame_dct) &&
 712         (p_vpar->mb.i_mb_type & (MB_PATTERN|MB_INTRA)) )
 713     {
 714         if( p_vpar->mb.b_dct_type = GetBits( &p_vpar->bit_stream, 1 ) )
 715         {
 716             /* The DCT is coded on fields. Jump one line between each
 717              * sample. */
 718             p_mb->i_addb_l_stride <<= 1;
 719             p_mb->i_addb_l_stride += 8;
 720             /* With CHROMA_420, the DCT is necessarily frame-coded. */
 721             if( p_vpar->picture.sequence.i_chroma_format != CHROMA_420 )
 722             {
 723                 p_mb->i_addb_c_stride <<= 1;
 724                 p_mb->i_addb_c_stride += 8;
 725             }
 726         }
 727     }
 728
 729     p_vpar->mb.b_dmv = p_vpar->mb.i_motion_type == MOTION_DMV;
 730 }
 731
 732 /*****************************************************************************
 733  * vpar_IMBType : macroblock_type in I pictures
 734  *****************************************************************************/
 735 int vpar_IMBType( vpar_thread_t * p_vpar )
 736 {
 737     /* Take two bits for testing */
 738     int                 i_type = ShowBits( &p_vpar->bit_stream, 2 );
 739     /* Lookup table for macroblock_type */
 740     static lookup_t     pl_mb_Itype[4] = { {MB_ERROR, 0},
 741                                           {MB_QUANT|MB_INTRA, 2},
 742                                           {MB_INTRA, 1},
 743                                           {MB_INTRA, 2} };
 744     /* Dump the good number of bits */
 745     DumpBits( &p_vpar->bit_stream, pl_mb_Itype[i_type].i_length );
 746     return pl_mb_Itype[i_type];
 747 }
 748
 749 /*****************************************************************************
 750  * vpar_PMBType : macroblock_type in P pictures
 751  *****************************************************************************/
 752 int vpar_PMBType( vpar_thread_t * p_vpar )
 753 {
 754     /* Testing on 6 bits */
 755     int                i_type = ShowBits( &p_vpar->bit_stream, 6 );
 756     /* Dump the good number of bits */
 757     DumpBits( &p_vpar->bit_stream, p_vpar->pm_mb_type[0][i_type].i_length );
 758     /* return the value from the lookup table for P type */
 759     return p_vpar->pm_mb_type[0][i_type].i_value;
 760 }
 761
 762 /*****************************************************************************
 763  * vpar_BMBType : macroblock_type in B pictures
 764  *****************************************************************************/
 765 int vpar_BMBType( vpar_thread_t * p_vpar )
 766 {
 767      /* Testing on 6 bits */
 768     int                i_type = ShowBits( &p_vpar->bit_stream, 6 );
 769     /* Dump the good number of bits */
 770     DumpBits( &p_vpar->bit_stream, p_vpar->pm_mb_type[1][i_type].i_length );
 771     /* return the value from the lookup table for B type */
 772     return p_vpar->pm_mb_type[1][i_type].i_value;
 773 }
 774
 775 /*****************************************************************************
 776  * vpar_DMBType : macroblock_type in D pictures
 777  *****************************************************************************/
 778 int vpar_DMBType( vpar_thread_t * p_vpar )
 779 {
 780     /* Taking 1 bit */
 781     int               i_type = GetBits( &p_vpar->bit_stream, 1 );
 782     /* Lookup table */
 783     static int        pi_mb_Dtype[2] = { MB_ERROR, 1 };
 784     return pi_mb_Dtype[i_type];
 785 }
 786
 787 /*****************************************************************************
 788  * vpar_CodedPattern420 : coded_block_pattern with 420 chroma
 789  *****************************************************************************/
 790 int vpar_CodedPattern420( vpar_thread_t * p_vpar )
 791 {
 792     int      i_vlc = ShowBits( p_vpar->bit_stream, 9 );
 793     DumpBits( p_vpar->bit_stream, p_vpar->pl_coded_pattern[i_vlc].i_length );
 794     return p_vpar->pl_coded_pattern[i_vlc].i_value;
 795 }
 796
 797 /*****************************************************************************
 798  * vpar_CodedPattern422 : coded_block_pattern with 422 chroma
 799  *****************************************************************************/
 800 int vpar_CodedPattern422( vpar_thread_t * p_vpar )
 801 {
 802     /* À pomper dans Berkeley + attention ! y'a 2 bits en plus en MPEG2 */
 803 }
 804
 805 /*****************************************************************************
 806  * vpar_CodedPattern444 : coded_block_pattern with 444 chroma
 807  *****************************************************************************/
 808 int vpar_CodedPattern444( vpar_thread_t * p_vpar )
 809 {
 810     /* À pomper dans Berkeley + attention ! y'a 4 bits en plus en MPEG2 */
 811 }
 812
 813 /*****************************************************************************
 814  * vpar_DecodeMPEG1Non : decode MPEG-1 non-intra blocks
 815  *****************************************************************************/
 816 static void vpar_DecodeMPEG1Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 817 {
 818     /* À pomper dans Berkeley. Pour toutes ces fonctions, il faut mettre
 819        p_mb->pf_idct[i_b] à :
 820         - vdec_IDCT ou
 821         - vdec_SparseIDCT si la matrice n'a qu'un coefficient non nul.
 822        Dans le deuxième cas, p_mb->pi_sparse_pos[i_b] contient le numéro
 823        de ce coefficient. */
 824
 825     if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
 826     {
 827         /* Remove end_of_macroblock (always 1, prevents startcode emulation)
 828          * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
 829         DumpBits( &p_vpar->bit_stream, 1 );
 830     }
 831 }
 832
 833 /*****************************************************************************
 834  * vpar_DecodeMPEG1Intra : decode MPEG-1 intra blocks
 835  *****************************************************************************/
 836 static void vpar_DecodeMPEG1Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 837 {
 838     /* À pomper dans Berkeley. */
 839
 840     if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
 841     {
 842         /* Remove end_of_macroblock (always 1, prevents startcode emulation)
 843          * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
 844         DumpBits( &p_vpar->bit_stream, 1 );
 845     }
 846 }
 847
 848 /*****************************************************************************
 849  * vpar_DecodeMPEG2Non : decode MPEG-2 non-intra blocks
 850  *****************************************************************************/
 851 static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 852 {
 853     /* À pomper dans Berkeley. Bien sûr les matrices seront différentes... */
 854 }
 855
 856 /*****************************************************************************
 857  * vpar_DecodeMPEG2Intra : decode MPEG-2 intra blocks
 858  *****************************************************************************/
 859 static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 860 {
 861     /* Lookup Table for the chromatic component */
 862     static int pi_cc_index[12] = { 0, 0, 0, 0, 1, 2, 1, 2, 1, 2 };
 863     int        i_cc = pi_cc_index[i_b];
 864     /* Determine whether it is luminance or not (chrominance) */
 865     int        i_type = ( i_cc + 1 ) / 2;
 866
 867     /* Decoding of the DC intra coefficient */
 868     /* The nb of bits to parse depends on i_type */
 869     int        i_code = ShowBits( &p_vpar->bit_stream, 9 + i_type );
 870     /* To reduce memory occupation, there are two lookup tables
 871      * See InitDCT above */
 872     int        i_code5 = i_code >> 4;
 873     /* Shall we lookup in the first or in the second table ? */
 874     int        i_select = ( i_code5 - 1 ) / 31;
 875     /* Offset value for looking in the second table */
 876     int        i_offset = 0x1f0 + ( i_type * 0x1f0 );
 877     int        i_pos = i_code5 * ( ! i_select ) +
 878                        ( i_code - i_offset ) * i_select;
 879     int        i_dct_dc_size;
 880     int        i_dct_dc_diff;
 881     i_dct_dc_size = p_vpar->pppl_dct_dc_size[i_select][i_type][i_pos].i_value;
 882     /* Dump the variable length code */
 883     DumpBits( &p_vpar->bit_stream,
 884               pppl_dct_dc_size[i_select][i_type][i_pos].i_length );
 885     i_dct_diff = GetBits( &p_vpar->bit_stream, i_dct_dc_size );
 886     p_vpar->slice.pi_dct_dc_pred[i_cc] += i_dct_diff;
 887
 888     /* Decoding of the AC coefficients */
 889     int        i_dummy = 1;
 890
 891 }