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 void InitMbAddrInc( vpar_thread_t * p_vpar )
 172 {
 173     bzero( &p_vpar->mb_addr_inc, 4096*sizeof( int ) );
 174     p_vpar->mb_addr_inc[8].i_value = MACROBLOCK_ESCAPE;
 175     p_vpar->mb_addr_inc[15].i_value = MACROBLOCK_STUFFING;
 176     p_vpar->mb_addr_inc[24].i_value = 33;
 177     p_vpar->mb_addr_inc[25].i_value = 32;
 178     p_vpar->mb_addr_inc[26].i_value = 31;
 179     p_vpar->mb_addr_inc[27].i_value = 30;
 180     p_vpar->mb_addr_inc[28].i_value = 29;
 181     p_vpar->mb_addr_inc[29].i_value = 28;
 182     p_vpar->mb_addr_inc[30].i_value = 27;
 183     p_vpar->mb_addr_inc[31].i_value = 26;
 184     p_vpar->mb_addr_inc[32].i_value = 25;
 185     p_vpar->mb_addr_inc[33].i_value = 24;
 186     p_vpar->mb_addr_inc[34].i_value = 23;
 187     p_vpar->mb_addr_inc[35].i_value = 22;
 188     p_vpar->mb_addr_inc[36].i_value = 21;
 189     p_vpar->mb_addr_inc[38].i_value = 20;
 190     p_vpar->mb_addr_inc[40].i_value = 19;
 191     p_vpar->mb_addr_inc[42].i_value = 18;
 192     p_vpar->mb_addr_inc[44].i_value = 17;
 193     p_vpar->mb_addr_inc[46].i_value = 16;
 194     p_vpar->mb_addr_inc[48].i_value = 15;
 195     p_vpar->mb_addr_inc[56].i_value = 14;
 196     p_vpar->mb_addr_inc[64].i_value = 13;
 197     p_vpar->mb_addr_inc[72].i_value = 12;
 198     p_vpar->mb_addr_inc[80].i_value = 11;
 199     p_vpar->mb_addr_inc[88].i_value = 10;
 200     p_vpar->mb_addr_inc[96].i_value = 9;
 201     p_vpar->mb_addr_inc[112].i_value = 8;
 202     p_vpar->mb_addr_inc[128].i_value = 7;
 203     p_vpar->mb_addr_inc[192].i_value = 6;
 204     p_vpar->mb_addr_inc[256].i_value = 5;
 205     p_vpar->mb_addr_inc[384].i_value = 4;
 206     p_vpar->mb_addr_inc[512].i_value = 3;
 207     p_vpar->mb_addr_inc[768].i_value = 2;
 208     p_vpar->mb_addr_inc[1024].i_value = 1;
 209     /* Length of the variable length code */
 210     p_vpar->mb_addr_inc[8].i_length = 11;
 211     p_vpar->mb_addr_inc[15].i_length = 11;
 212     p_vpar->mb_addr_inc[24].i_length = 11;
 213     p_vpar->mb_addr_inc[25].i_length = 11;
 214     p_vpar->mb_addr_inc[26].i_length = 11;
 215     p_vpar->mb_addr_inc[27].i_length = 11;
 216     p_vpar->mb_addr_inc[28].i_length = 11;
 217     p_vpar->mb_addr_inc[29].i_length = 11;
 218     p_vpar->mb_addr_inc[30].i_length = 11;
 219     p_vpar->mb_addr_inc[31].i_length = 11;
 220     p_vpar->mb_addr_inc[32].i_length = 11;
 221     p_vpar->mb_addr_inc[33].i_length = 11;
 222     p_vpar->mb_addr_inc[34].i_length = 11;
 223     p_vpar->mb_addr_inc[35].i_length = 11;
 224     p_vpar->mb_addr_inc[36].i_length = 10;
 225     p_vpar->mb_addr_inc[38].i_length = 10;
 226     p_vpar->mb_addr_inc[40].i_length = 10;
 227     p_vpar->mb_addr_inc[42].i_length = 10;
 228     p_vpar->mb_addr_inc[44].i_length = 10;
 229     p_vpar->mb_addr_inc[46].i_length = 10;
 230     p_vpar->mb_addr_inc[48].i_length = 8;
 231     p_vpar->mb_addr_inc[56].i_length = 8;
 232     p_vpar->mb_addr_inc[64].i_length = 8;
 233     p_vpar->mb_addr_inc[72].i_length = 8;
 234     p_vpar->mb_addr_inc[80].i_length = 8;
 235     p_vpar->mb_addr_inc[88].i_length = 8;
 236     p_vpar->mb_addr_inc[96].i_length = 7;
 237     p_vpar->mb_addr_inc[112].i_length = 7;
 238     p_vpar->mb_addr_inc[128].i_length = 5;
 239     p_vpar->mb_addr_inc[192].i_length = 5;
 240     p_vpar->mb_addr_inc[256].i_length = 4;
 241     p_vpar->mb_addr_inc[384].i_length = 4;
 242     p_vpar->mb_addr_inc[512].i_length = 3;
 243     p_vpar->mb_addr_inc[768].i_length = 3;
 244     p_vpar->mb_addr_inc[1024].i_length = 1;
 245 }
 246
 247 /*
 248  * Macroblock parsing functions
 249  */
 250
 251 /*****************************************************************************
 252  * vpar_ParseMacroblock : Parse the next macroblock
 253  *****************************************************************************/
 254 void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address,
 255                            int i_mb_previous, int i_mb_base )
 256 {
 257     static f_addb_t ppf_addb_intra[2] = {vdec_AddBlock, vdec_CopyBlock};
 258     static f_decode_block_t pppf_decode_block[2][2] =
 259                 { {vpar_DecodeMPEG1Non, vpar_DecodeMPEG1Intra},
 260                   {vpar_DecodeMPEG2Non, vpar_DecodeMPEG2Intra} };
 261     static int      pi_x[12] = {0,8,0,8,0,0,0,0,8,8,8,8};
 262     static int      pi_y[2][12] = { {0,0,8,8,0,0,8,8,0,0,8,8},
 263                                     {0,0,1,1,0,0,1,1,0,0,1,1} };
 264     static int      pi_chroma_hor[4] = { 0, 1, 1, 0 };
 265     static int      pi_chroma_ver[4] = { 0, 1, 0, 0 };
 266
 267     int             i_mb, i_b, i_mask;
 268     macroblock_t *  p_mb;
 269     f_addb_t        pf_addb;
 270     elem_t *        p_data1;
 271     elem_t *        p_data2;
 272
 273     *pi_mb_address += MacroblockAddressIncrement( p_vpar );
 274
 275     for( i_mb = i_mb_previous; i_mb < *pi_mb_address; i_mb++ )
 276     {
 277         /* Skipped macroblock (ISO/IEC 13818-2 7.6.6). */
 278         static int          pi_dc_dct_reinit[4] = {128,256,512,1024};
 279         static f_motion_t   pf_motion_skipped[4] = {NULL, vdec_MotionField,
 280                                 vdec_MotionField, vdec_MotionFrame};
 281
 282         /* Reset DC predictors (7.2.1). */
 283         p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
 284             = p_vpar->slice.pi_dc_dct_pred[2]
 285             = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
 286
 287         if( p_vpar->picture.i_coding_type == P_CODING_TYPE )
 288         {
 289             /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
 290             bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
 291         }
 292
 293         if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + i_mb] =
 294              vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
 295         {
 296             p_vpar->picture.b_error = 1;
 297             intf_ErrMsg("vpar error: macroblock list is empty !");
 298             return;
 299         }
 300
 301         InitMacroblock( p_vpar, p_mb );
 302
 303         /* No IDCT nor AddBlock. */
 304         for( i_b = 0; i_b < 12; i_b++ )
 305         {
 306             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 307             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 308         }
 309
 310         /* Motion type is picture structure. */
 311         p_mb->pf_motion = pf_motion_skipped[p_vpar->picture.i_structure];
 312
 313         /* Predict from field of same parity. */
 314         /* ??? */
 315     }
 316
 317     /* Get a macroblock structure. */
 318     if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + *pi_mb_address] =
 319          vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
 320     {
 321         p_vpar->picture.b_error = 1;
 322         intf_ErrMsg("vpar error: macroblock list is empty !");
 323         return;
 324     }
 325
 326     InitMacroblock( p_vpar, p_mb );
 327
 328     /* Parse off macroblock_modes structure. */
 329     MacroblockModes( p_vpar, p_mb );
 330
 331     if( p_vpar->mb.i_mb_type & MB_QUANT )
 332     {
 333         LoadQuantizerScale( p_vpar );
 334     }
 335
 336     if( p_vpar->mb.i_mb_type & MB_MOTION_FORWARD )
 337     {
 338         (*p_vpar->sequence.pf_decode_mv)( p_vpar, 0 );
 339     }
 340
 341     if( p_vpar->mb.i_mb_type & MB_MOTION_BACKWARD )
 342     {
 343         (*p_vpar->sequence.pf_decode_mv)( p_vpar, 1 );
 344     }
 345
 346     if( p_vpar->picture.b_concealment_mv && (p_vpar->mb.i_mb_type & MB_INTRA) )
 347     {
 348         DumpBits( &p_vpar->bit_stream, 1 );
 349     }
 350
 351     if( p_vpar->mb.i_mb_type & MB_PATTERN )
 352     {
 353         (*p_vpar->sequence.pf_decode_pattern)( p_vpar );
 354     }
 355     else
 356     {
 357         int     pi_coded_block_pattern[2] = {0,
 358                     (1 << 4+2*p_vpar->sequence.i_chroma_nb_blocks) - 1};
 359         p_vpar->mb.i_coded_block_pattern = pi_coded_block_pattern
 360                                     [p_vpar->mb.i_mb_type & MB_INTRA];
 361     }
 362
 363     pf_addb = ppf_addb_intra[p_vpar->mb.i_mb_type & MB_INTRA];
 364
 365     /*
 366      * Effectively decode blocks.
 367      */
 368
 369     i_mask = 1 << (3 + 2*p_vpar->sequence.i_chroma_nb_blocks);
 370
 371     /* luminance */
 372     p_data1 = p_mb->p_picture->p_y
 373               + p_mb->i_l_x + p_mb->i_l_y*(p_vpar->sequence.i_width);
 374
 375     for( i_b = 0; i_b < 4; i_b++, i_mask >>= 1 )
 376     {
 377         if( p_vpar->mb.i_coded_block_pattern & i_mask )
 378         {
 379             memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
 380             (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
 381                                [p_vpar->mb.i_mb_type & MB_INTRA])
 382                 ( p_vpar, p_mb, i_b );
 383
 384             /* decode_block has already set pf_idct and pi_sparse_pos. */
 385             p_mb->pf_addb[i_b] = pf_addb;
 386
 387             /* Calculate block coordinates. */
 388             p_mb->p_data[i_b] = p_data1
 389                                  + pi_y[p_vpar->mb.b_dct_type][i_b]
 390                                    * p_vpar->sequence.i_chroma_width;
 391         }
 392         else
 393         {
 394             /* Block not coded, so no IDCT, nor AddBlock */
 395             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 396             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 397         }
 398     }
 399
 400     /* chrominance U */
 401     p_data1 = p_mb->p_picture->p_u
 402               + p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]
 403               + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
 404                 * (p_vpar->sequence.i_chroma_width);
 405     p_data2 = p_mb->p_picture->p_v
 406               + p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]
 407               + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
 408                 * (p_vpar->sequence.i_chroma_width);
 409
 410     for( i_b = 4; i_b < 4 + 2*p_vpar->sequence.i_chroma_nb_blocks;
 411          i_b++, i_mask >>= 1 )
 412     {
 413         elem_t *    pp_data[2] = {p_data1, p_data2};
 414
 415         if( p_vpar->mb.i_coded_block_pattern & i_mask )
 416         {
 417             memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
 418             (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
 419                                [p_vpar->mb.i_mb_type & MB_INTRA])
 420                 ( p_vpar, p_mb, i_b );
 421
 422             /* decode_block has already set pf_idct and pi_sparse_pos. */
 423             p_mb->pf_addb[i_b] = pf_addb;
 424
 425             /* Calculate block coordinates. */
 426             p_mb->p_data[i_b] = pp_data[i_b & 1]
 427                                  + pi_y[p_vpar->mb.b_dct_type][i_b]
 428                                    * p_vpar->sequence.i_chroma_width;
 429         }
 430         else
 431         {
 432             /* Block not coded, so no IDCT, nor AddBlock */
 433             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 434             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 435         }
 436     }
 437
 438     if( !( p_vpar->mb.i_mb_type & MB_INTRA ) )
 439     {
 440         static int          pi_dc_dct_reinit[4] = {128,256,512,1024};
 441
 442         /* Reset DC predictors (7.2.1). */
 443         p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
 444             = p_vpar->slice.pi_dc_dct_pred[2]
 445             = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
 446     }
 447     else if( !p_vpar->picture.b_concealment_mv )
 448     {
 449         /* Reset MV predictors. */
 450         bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
 451     }
 452
 453     if( (p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
 454         !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD|MB_INTRA)) )
 455     {
 456         /* Special No-MC macroblock in P pictures (7.6.3.5). */
 457         p_vpar->slice.pppi_pmv[0][0][0] = p_vpar->slice.pppi_pmv[0][0][1] =
 458         p_vpar->slice.pppi_pmv[1][0][0] = p_vpar->slice.pppi_pmv[1][0][1] = 0;
 459
 460         /* motion type ?????? */
 461         /* predict from field of same parity ????? */
 462     }
 463 }
 464
 465 /*****************************************************************************
 466  * InitMacroblock : Initialize macroblock values
 467  *****************************************************************************/
 468 static __inline__ void InitMacroblock( vpar_thread_t * p_vpar,
 469                                        macroblock_t * p_mb )
 470 {
 471     p_mb->p_picture = p_vpar->picture.p_picture;
 472     p_mb->i_structure = p_vpar->picture.i_structure;
 473     p_mb->i_l_x = p_vpar->mb.i_l_x;
 474     p_mb->i_l_y = p_vpar->mb.i_l_y;
 475     p_mb->i_c_x = p_vpar->mb.i_c_x;
 476     p_mb->i_c_y = p_vpar->mb.i_c_y;
 477     p_mb->i_chroma_nb_blocks = p_vpar->sequence.i_chroma_nb_blocks;
 478
 479     p_mb->i_addb_l_stride = p_mb->i_l_stride = p_vpar->picture.i_l_stride;
 480     p_mb->i_addb_c_stride = p_mb->i_c_stride = p_vpar->picture.i_c_stride;
 481
 482     /* Update macroblock real position. */
 483     p_vpar->mb.i_l_x += 16;
 484     p_vpar->mb.i_l_y += (p_vpar->mb.i_l_x / p_vpar->sequence.i_width)
 485                         * (2 - p_vpar->picture.b_frame_structure) * 16;
 486     p_vpar->mb.i_l_x %= p_vpar->sequence.i_width;
 487
 488     p_vpar->mb.i_c_x += p_vpar->sequence.i_chroma_mb_width;
 489     p_vpar->mb.i_c_y += (p_vpar->mb.i_c_x / p_vpar->sequence.i_chroma_width)
 490                         * (2 - p_vpar->picture.b_frame_structure)
 491                         * p_vpar->sequence.i_chroma_mb_height;
 492     p_vpar->mb.i_c_x %= p_vpar->sequence.i_chroma_width;
 493 }
 494
 495 /*****************************************************************************
 496  * MacroblockAddressIncrement : Get the macroblock_address_increment field
 497  *****************************************************************************/
 498 static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar )
 499 {
 500     /* Index in the lookup table mb_addr_inc */
 501     int    i_index = ShowBits( &p_vpar->bit_stream, 11 );
 502     p_vpar->mb.i_addr_inc = 0;
 503     /* Test the presence of the escape character */
 504     while( i_index == 8 )
 505     {
 506         DumpBits( &p_vpar->bit_stream, 11 );
 507         p_vpar->mb.i_addr_inc += 33;
 508         i_index = ShowBits( &p_vpar->bit_stream, 11 );
 509     }
 510     /* Affect the value from the lookup table */
 511     p_vpar->mb.i_addr_inc += p_vpar->mb_addr_inc[i_index].i_value;
 512     /* Dump the good number of bits */
 513     DumpBits( &p_vpar->bit_stream, p_vpar->mb_addr_inc[i_index].i_length );
 514 }
 515
 516 /*****************************************************************************
 517  * MacroblockModes : Get the macroblock_modes structure
 518  *****************************************************************************/
 519 static __inline__ void MacroblockModes( vpar_thread_t * p_vpar,
 520                                         macroblock_t * p_mb )
 521 {
 522     static f_motion_t   pf_motion[2][4] =
 523         { {NULL, vdec_FieldRecon, vdec_16x8Recon, vdec_DMVRecon},
 524           {NULL, vdec_FieldRecon, vdec_FrameRecon, vdec_DMVRecon} };
 525     static int          ppi_mv_count[2][4] = { {0, 1, 2, 1}, {0, 2, 1, 1} };
 526     static int          ppi_mv_format[2][4] = { {0, 1, 1, 1}, {0, 1, 2, 1} };
 527
 528     /* Get macroblock_type. */
 529     p_vpar->mb.i_mb_type = (p_vpar->picture.pf_macroblock_type)
 530                                   ( vpar_thread_t * p_vpar );
 531
 532     /* SCALABILITY : warning, we don't know if spatial_temporal_weight_code
 533      * has to be dropped, take care if you use scalable streams. */
 534     /* DumpBits( &p_vpar->bit_stream, 2 ); */
 535
 536     if( !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD | MB_MOTION_BACKWARD))
 537         || p_vpar->picture.b_frame_pred_frame_dct )
 538     {
 539         /* If mb_type has neither MOTION_FORWARD nor MOTION_BACKWARD, this
 540          * is useless, but also harmless. */
 541         p_vpar->mb.i_motion_type = MOTION_FRAME;
 542     }
 543     else
 544     {
 545         p_vpar->mb.i_motion_type = GetBits( &p_vpar->bit_stream, 2 );
 546     }
 547
 548     p_mb->pf_motion = pf_motion[p_vpar->picture.b_frame_structure]
 549                               [p_vpar->mb.i_motion_type];
 550     p_vpar->mb.i_mv_count = ppi_mv_count[p_vpar->picture.b_frame_structure]
 551                                         [p_vpar->mb.i_motion_type];
 552     p_vpar->mb.i_mv_format = ppi_mv_format[p_vpar->picture.b_frame_structure]
 553                                           [p_vpar->mb.i_motion_type];
 554
 555     p_vpar->mb.b_dct_type = 0;
 556     if( (p_vpar->picture.i_structure == FRAME_STRUCTURE) &&
 557         (!p_vpar->picture.b_frame_pred_frame_dct) &&
 558         (p_vpar->mb.i_mb_type & (MB_PATTERN|MB_INTRA)) )
 559     {
 560         if( p_vpar->mb.b_dct_type = GetBits( &p_vpar->bit_stream, 1 ) )
 561         {
 562             /* The DCT is coded on fields. Jump one line between each
 563              * sample. */
 564             p_mb->i_addb_l_stride <<= 1;
 565             p_mb->i_addb_l_stride += 8;
 566             /* With CHROMA_420, the DCT is necessarily frame-coded. */
 567             if( p_vpar->picture.sequence.i_chroma_format != CHROMA_420 )
 568             {
 569                 p_mb->i_addb_c_stride <<= 1;
 570                 p_mb->i_addb_c_stride += 8;
 571             }
 572         }
 573     }
 574
 575     p_vpar->mb.b_dmv = p_vpar->mb.i_motion_type == MOTION_DMV;
 576 }
 577
 578 /*****************************************************************************
 579  * vpar_IMBType : macroblock_type in I pictures
 580  *****************************************************************************/
 581 int vpar_IMBType( vpar_thread_t * p_vpar )
 582 {
 583     /* À pomper dans Berkeley */
 584 }
 585
 586 /*****************************************************************************
 587  * vpar_PMBType : macroblock_type in P pictures
 588  *****************************************************************************/
 589 int vpar_PMBType( vpar_thread_t * p_vpar )
 590 {
 591     /* À pomper dans Berkeley */
 592 }
 593
 594 /*****************************************************************************
 595  * vpar_BMBType : macroblock_type in B pictures
 596  *****************************************************************************/
 597 int vpar_BMBType( vpar_thread_t * p_vpar )
 598 {
 599     /* À pomper dans Berkeley */
 600 }
 601
 602 /*****************************************************************************
 603  * vpar_DMBType : macroblock_type in D pictures
 604  *****************************************************************************/
 605 int vpar_DMBType( vpar_thread_t * p_vpar )
 606 {
 607     /* À pomper dans Berkeley */
 608 }
 609
 610 /*****************************************************************************
 611  * vpar_CodedPattern420 : coded_block_pattern with 420 chroma
 612  *****************************************************************************/
 613 int vpar_CodedPattern420( vpar_thread_t * p_vpar )
 614 {
 615     /* À pomper dans Berkeley */
 616 }
 617
 618 /*****************************************************************************
 619  * vpar_CodedPattern422 : coded_block_pattern with 422 chroma
 620  *****************************************************************************/
 621 int vpar_CodedPattern422( vpar_thread_t * p_vpar )
 622 {
 623     /* À pomper dans Berkeley + attention ! y'a 2 bits en plus en MPEG2 */
 624 }
 625
 626 /*****************************************************************************
 627  * vpar_CodedPattern444 : coded_block_pattern with 444 chroma
 628  *****************************************************************************/
 629 int vpar_CodedPattern444( vpar_thread_t * p_vpar )
 630 {
 631     /* À pomper dans Berkeley + attention ! y'a 4 bits en plus en MPEG2 */
 632 }
 633
 634 /*****************************************************************************
 635  * vpar_DecodeMPEG1Non : decode MPEG-1 non-intra blocks
 636  *****************************************************************************/
 637 static void vpar_DecodeMPEG1Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 638 {
 639     /* À pomper dans Berkeley. Pour toutes ces fonctions, il faut mettre
 640        p_mb->pf_idct[i_b] à :
 641         - vdec_IDCT ou
 642         - vdec_SparseIDCT si la matrice n'a qu'un coefficient non nul.
 643        Dans le deuxième cas, p_mb->pi_sparse_pos[i_b] contient le numéro
 644        de ce coefficient. */
 645
 646     if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
 647     {
 648         /* Remove end_of_macroblock (always 1, prevents startcode emulation)
 649          * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
 650         DumpBits( &p_vpar->bit_stream, 1 );
 651     }
 652 }
 653
 654 /*****************************************************************************
 655  * vpar_DecodeMPEG1Intra : decode MPEG-1 intra blocks
 656  *****************************************************************************/
 657 static void vpar_DecodeMPEG1Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 658 {
 659     /* À pomper dans Berkeley. */
 660
 661     if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
 662     {
 663         /* Remove end_of_macroblock (always 1, prevents startcode emulation)
 664          * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
 665         DumpBits( &p_vpar->bit_stream, 1 );
 666     }
 667 }
 668
 669 /*****************************************************************************
 670  * vpar_DecodeMPEG2Non : decode MPEG-2 non-intra blocks
 671  *****************************************************************************/
 672 static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 673 {
 674     /* À pomper dans Berkeley. Bien sûr les matrices seront différentes... */
 675 }
 676
 677 /*****************************************************************************
 678  * vpar_DecodeMPEG2Intra : decode MPEG-2 intra blocks
 679  *****************************************************************************/
 680 static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 681 {
 682     /* À pomper dans Berkeley. */
 683 }