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 static void vpar_DecodeMPEG1Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
  51 static void vpar_DecodeMPEG1Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
  52 static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
  53 static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
  54
  55 typedef void      (*f_decode_block_t)( vpar_thread_t *, macroblock_t *, int );
  56
  57 /*****************************************************************************
  58  * vpar_ParseMacroblock : Parse the next macroblock
  59  *****************************************************************************/
  60 void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address,
  61                            int i_mb_previous, int i_mb_base )
  62 {
  63     static f_addb_t ppf_addb_intra[2] = {vdec_AddBlock, vdec_CopyBlock};
  64     static f_decode_block_t pppf_decode_block[2][2] =
  65                 { {vpar_DecodeMPEG1Non, vpar_DecodeMPEG1Intra},
  66                   {vpar_DecodeMPEG2Non, vpar_DecodeMPEG2Intra} };
  67     static int      pi_x[12] = {0,8,0,8,0,0,0,0,8,8,8,8};
  68     static int      pi_y[2][12] = { {0,0,8,8,0,0,8,8,0,0,8,8},
  69                                     {0,0,1,1,0,0,1,1,0,0,1,1} };
  70     static int      pi_chroma_hor[4] = { 0, 1, 1, 0 };
  71     static int      pi_chroma_ver[4] = { 0, 1, 0, 0 };
  72
  73     int             i_mb, i_b, i_mask;
  74     macroblock_t *  p_mb;
  75     f_addb_t        pf_addb;
  76     elem_t *        p_data1;
  77     elem_t *        p_data2;
  78
  79     *pi_mb_address += MacroblockAddressIncrement( p_vpar );
  80
  81     for( i_mb = i_mb_previous; i_mb < *pi_mb_address; i_mb++ )
  82     {
  83         /* Skipped macroblock (ISO/IEC 13818-2 7.6.6). */
  84         static int          pi_dc_dct_reinit[4] = {128,256,512,1024};
  85         static f_motion_t   pf_motion_skipped[4] = {NULL, vdec_MotionField,
  86                                 vdec_MotionField, vdec_MotionFrame};
  87
  88         /* Reset DC predictors (7.2.1). */
  89         p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
  90             = p_vpar->slice.pi_dc_dct_pred[2]
  91             = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
  92
  93         if( p_vpar->picture.i_coding_type == P_CODING_TYPE )
  94         {
  95             /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
  96             bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
  97         }
  98
  99         if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + i_mb] =
 100              vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
 101         {
 102             p_vpar->picture.b_error = 1;
 103             intf_ErrMsg("vpar error: macroblock list is empty !");
 104             return;
 105         }
 106
 107         InitMacroblock( p_vpar, p_mb );
 108
 109         /* No IDCT nor AddBlock. */
 110         for( i_b = 0; i_b < 12; i_b++ )
 111         {
 112             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 113             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 114         }
 115
 116         /* Motion type is picture structure. */
 117         p_mb->pf_motion = pf_motion_skipped[p_vpar->picture.i_structure];
 118
 119         /* Predict from field of same parity. */
 120         /* ??? */
 121     }
 122
 123     /* Get a macroblock structure. */
 124     if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + *pi_mb_address] =
 125          vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
 126     {
 127         p_vpar->picture.b_error = 1;
 128         intf_ErrMsg("vpar error: macroblock list is empty !");
 129         return;
 130     }
 131
 132     InitMacroblock( p_vpar, p_mb );
 133
 134     /* Parse off macroblock_modes structure. */
 135     MacroblockModes( p_vpar, p_mb );
 136
 137     if( p_vpar->mb.i_mb_type & MB_QUANT )
 138     {
 139         LoadQuantizerScale( p_vpar );
 140     }
 141
 142     if( p_vpar->mb.i_mb_type & MB_MOTION_FORWARD )
 143     {
 144         (*p_vpar->sequence.pf_decode_mv)( p_vpar, 0 );
 145     }
 146
 147     if( p_vpar->mb.i_mb_type & MB_MOTION_BACKWARD )
 148     {
 149         (*p_vpar->sequence.pf_decode_mv)( p_vpar, 1 );
 150     }
 151
 152     if( p_vpar->picture.b_concealment_mv && (p_vpar->mb.i_mb_type & MB_INTRA) )
 153     {
 154         DumpBits( &p_vpar->bit_stream, 1 );
 155     }
 156
 157     if( p_vpar->mb.i_mb_type & MB_PATTERN )
 158     {
 159         (*p_vpar->sequence.pf_decode_pattern)( p_vpar );
 160     }
 161     else
 162     {
 163         int     pi_coded_block_pattern[2] = {0,
 164                     (1 << 4+2*p_vpar->sequence.i_chroma_nb_blocks) - 1};
 165         p_vpar->mb.i_coded_block_pattern = pi_coded_block_pattern
 166                                     [p_vpar->mb.i_mb_type & MB_INTRA];
 167     }
 168
 169     pf_addb = ppf_addb_intra[p_vpar->mb.i_mb_type & MB_INTRA];
 170
 171     /*
 172      * Effectively decode blocks.
 173      */
 174
 175     i_mask = 1 << (3 + 2*p_vpar->sequence.i_chroma_nb_blocks);
 176
 177     /* luminance */
 178     p_data1 = p_mb->p_picture->p_y
 179               + p_mb->i_l_x + p_mb->i_l_y*(p_vpar->sequence.i_width);
 180
 181     for( i_b = 0; i_b < 4; i_b++, i_mask >>= 1 )
 182     {
 183         if( p_vpar->mb.i_coded_block_pattern & i_mask )
 184         {
 185             memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
 186             (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
 187                                [p_vpar->mb.i_mb_type & MB_INTRA])
 188                 ( p_vpar, p_mb, i_b );
 189
 190             /* decode_block has already set pf_idct and pi_sparse_pos. */
 191             p_mb->pf_addb[i_b] = pf_addb;
 192
 193             /* Calculate block coordinates. */
 194             p_mb->p_data[i_b] = p_data1
 195                                  + pi_y[p_vpar->mb.b_dct_type][i_b]
 196                                    * p_vpar->sequence.i_chroma_width;
 197         }
 198         else
 199         {
 200             /* Block not coded, so no IDCT, nor AddBlock */
 201             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 202             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 203         }
 204     }
 205
 206     /* chrominance U */
 207     p_data1 = p_mb->p_picture->p_u
 208               + p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]
 209               + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
 210                 * (p_vpar->sequence.i_chroma_width);
 211     p_data2 = p_mb->p_picture->p_v
 212               + p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]
 213               + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
 214                 * (p_vpar->sequence.i_chroma_width);
 215
 216     for( i_b = 4; i_b < 4 + 2*p_vpar->sequence.i_chroma_nb_blocks;
 217          i_b++, i_mask >>= 1 )
 218     {
 219         elem_t *    pp_data[2] = {p_data1, p_data2};
 220
 221         if( p_vpar->mb.i_coded_block_pattern & i_mask )
 222         {
 223             memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
 224             (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
 225                                [p_vpar->mb.i_mb_type & MB_INTRA])
 226                 ( p_vpar, p_mb, i_b );
 227
 228             /* decode_block has already set pf_idct and pi_sparse_pos. */
 229             p_mb->pf_addb[i_b] = pf_addb;
 230
 231             /* Calculate block coordinates. */
 232             p_mb->p_data[i_b] = pp_data[i_b & 1]
 233                                  + pi_y[p_vpar->mb.b_dct_type][i_b]
 234                                    * p_vpar->sequence.i_chroma_width;
 235         }
 236         else
 237         {
 238             /* Block not coded, so no IDCT, nor AddBlock */
 239             p_mb->pf_addb[i_b] = vdec_DummyBlock;
 240             p_mb->pf_idct[i_b] = vdec_DummyIDCT;
 241         }
 242     }
 243
 244     if( !( p_vpar->mb.i_mb_type & MB_INTRA ) )
 245     {
 246         static int          pi_dc_dct_reinit[4] = {128,256,512,1024};
 247
 248         /* Reset DC predictors (7.2.1). */
 249         p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
 250             = p_vpar->slice.pi_dc_dct_pred[2]
 251             = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
 252     }
 253     else if( !p_vpar->picture.b_concealment_mv )
 254     {
 255         /* Reset MV predictors. */
 256         bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
 257     }
 258
 259     if( (p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
 260         !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD|MB_INTRA)) )
 261     {
 262         /* Special No-MC macroblock in P pictures (7.6.3.5). */
 263         p_vpar->slice.pppi_pmv[0][0][0] = p_vpar->slice.pppi_pmv[0][0][1] =
 264         p_vpar->slice.pppi_pmv[1][0][0] = p_vpar->slice.pppi_pmv[1][0][1] = 0;
 265
 266         /* motion type ?????? */
 267         /* predict from field of same parity ????? */
 268     }
 269 }
 270
 271 /*****************************************************************************
 272  * InitMacroblock : Initialize macroblock values
 273  *****************************************************************************/
 274 static __inline__ void InitMacroblock( vpar_thread_t * p_vpar,
 275                                        macroblock_t * p_mb )
 276 {
 277     p_mb->p_picture = p_vpar->picture.p_picture;
 278     p_mb->i_structure = p_vpar->picture.i_structure;
 279     p_mb->i_l_x = p_vpar->mb.i_l_x;
 280     p_mb->i_l_y = p_vpar->mb.i_l_y;
 281     p_mb->i_c_x = p_vpar->mb.i_c_x;
 282     p_mb->i_c_y = p_vpar->mb.i_c_y;
 283     p_mb->i_chroma_nb_blocks = p_vpar->sequence.i_chroma_nb_blocks;
 284
 285     p_mb->i_l_stride = p_vpar->picture.i_l_stride;
 286     p_mb->i_c_stride = p_vpar->picture.i_c_stride;
 287
 288     /* Update macroblock real position. */
 289     p_vpar->mb.i_l_x += 16;
 290     p_vpar->mb.i_l_y += (p_vpar->mb.i_l_x / p_vpar->sequence.i_width)
 291                         * (2 - p_vpar->picture.b_frame_structure) * 16;
 292     p_vpar->mb.i_l_x %= p_vpar->sequence.i_width;
 293
 294     p_vpar->mb.i_c_x += p_vpar->sequence.i_chroma_mb_width;
 295     p_vpar->mb.i_c_y += (p_vpar->mb.i_c_x / p_vpar->sequence.i_chroma_width)
 296                         * (2 - p_vpar->picture.b_frame_structure)
 297                         * p_vpar->sequence.i_chroma_mb_height;
 298     p_vpar->mb.i_c_x %= p_vpar->sequence.i_chroma_width;
 299 }
 300
 301 /*****************************************************************************
 302  * MacroblockAddressIncrement : Get the macroblock_address_increment field
 303  *****************************************************************************/
 304 static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar )
 305 {
 306     /* À pomper dans Berkeley */
 307 }
 308
 309 /*****************************************************************************
 310  * MacroblockModes : Get the macroblock_modes structure
 311  *****************************************************************************/
 312 static __inline__ void MacroblockModes( vpar_thread_t * p_vpar,
 313                                         macroblock_t * p_mb )
 314 {
 315     static f_motion_t   pf_motion[2][4] =
 316         { {NULL, vdec_FieldRecon, vdec_16x8Recon, vdec_DMVRecon},
 317           {NULL, vdec_FieldRecon, vdec_FrameRecon, vdec_DMVRecon} };
 318     static int          ppi_mv_count[2][4] = { {0, 1, 2, 1}, {0, 2, 1, 1} };
 319     static int          ppi_mv_format[2][4] = { {0, 1, 1, 1}, {0, 1, 2, 1} };
 320
 321     /* Get macroblock_type. */
 322     p_vpar->mb.i_mb_type = (p_vpar->picture.pf_macroblock_type)
 323                                   ( vpar_thread_t * p_vpar );
 324
 325     /* SCALABILITY : warning, we don't know if spatial_temporal_weight_code
 326      * has to be dropped, take care if you use scalable streams. */
 327     /* DumpBits( &p_vpar->bit_stream, 2 ); */
 328
 329     if( !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD | MB_MOTION_BACKWARD))
 330         || p_vpar->picture.b_frame_pred_frame_dct )
 331     {
 332         /* If mb_type has neither MOTION_FORWARD nor MOTION_BACKWARD, this
 333          * is useless, but also harmless. */
 334         p_vpar->mb.i_motion_type = MOTION_FRAME;
 335     }
 336     else
 337     {
 338         p_vpar->mb.i_motion_type = GetBits( &p_vpar->bit_stream, 2 );
 339     }
 340
 341     p_mb->pf_motion = pf_motion[p_vpar->picture.b_frame_structure]
 342                               [p_vpar->mb.i_motion_type];
 343     p_vpar->mb.i_mv_count = ppi_mv_count[p_vpar->picture.b_frame_structure]
 344                                         [p_vpar->mb.i_motion_type];
 345     p_vpar->mb.i_mv_format = ppi_mv_format[p_vpar->picture.b_frame_structure]
 346                                           [p_vpar->mb.i_motion_type];
 347
 348     p_vpar->mb.b_dct_type = 0;
 349     if( (p_vpar->picture.i_structure == FRAME_STRUCTURE) &&
 350         (!p_vpar->picture.b_frame_pred_frame_dct) &&
 351         (p_vpar->mb.i_mb_type & (MB_PATTERN|MB_INTRA)) )
 352     {
 353         if( p_vpar->mb.b_dct_type = GetBits( &p_vpar->bit_stream, 1 ) )
 354         {
 355             p_mb->i_l_stride <<= 1;
 356             p_mb->i_l_stride += 8;
 357             p_mb->i_c_stride <<= 1;
 358             p_mb->i_c_stride += 8;
 359         }
 360     }
 361 }
 362
 363 /*****************************************************************************
 364  * vpar_IMBType : macroblock_type in I pictures
 365  *****************************************************************************/
 366 int vpar_IMBType( vpar_thread_t * p_vpar )
 367 {
 368     /* À pomper dans Berkeley */
 369 }
 370
 371 /*****************************************************************************
 372  * vpar_PMBType : macroblock_type in P pictures
 373  *****************************************************************************/
 374 int vpar_PMBType( vpar_thread_t * p_vpar )
 375 {
 376     /* À pomper dans Berkeley */
 377 }
 378
 379 /*****************************************************************************
 380  * vpar_BMBType : macroblock_type in B pictures
 381  *****************************************************************************/
 382 int vpar_BMBType( vpar_thread_t * p_vpar )
 383 {
 384     /* À pomper dans Berkeley */
 385 }
 386
 387 /*****************************************************************************
 388  * vpar_DMBType : macroblock_type in D pictures
 389  *****************************************************************************/
 390 int vpar_DMBType( vpar_thread_t * p_vpar )
 391 {
 392     /* À pomper dans Berkeley */
 393 }
 394
 395 /*****************************************************************************
 396  * vpar_CodedPattern420 : coded_block_pattern with 420 chroma
 397  *****************************************************************************/
 398 int vpar_CodedPattern420( vpar_thread_t * p_vpar )
 399 {
 400     /* À pomper dans Berkeley */
 401 }
 402
 403 /*****************************************************************************
 404  * vpar_CodedPattern422 : coded_block_pattern with 422 chroma
 405  *****************************************************************************/
 406 int vpar_CodedPattern422( vpar_thread_t * p_vpar )
 407 {
 408     /* À pomper dans Berkeley + attention ! y'a 2 bits en plus en MPEG2 */
 409 }
 410
 411 /*****************************************************************************
 412  * vpar_CodedPattern444 : coded_block_pattern with 444 chroma
 413  *****************************************************************************/
 414 int vpar_CodedPattern444( vpar_thread_t * p_vpar )
 415 {
 416     /* À pomper dans Berkeley + attention ! y'a 4 bits en plus en MPEG2 */
 417 }
 418
 419 /*****************************************************************************
 420  * vpar_DecodeMPEG1Non : decode MPEG-1 non-intra blocks
 421  *****************************************************************************/
 422 static void vpar_DecodeMPEG1Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 423 {
 424     /* À pomper dans Berkeley. Pour toutes ces fonctions, il faut mettre
 425        p_mb->pf_idct[i_b] à :
 426         - vdec_IDCT ou
 427         - vdec_SparseIDCT si la matrice n'a qu'un coefficient non nul.
 428        Dans le deuxième cas, p_mb->pi_sparse_pos[i_b] contient le numéro
 429        de ce coefficient. */
 430
 431     if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
 432     {
 433         /* Remove end_of_macroblock (always 1, prevents startcode emulation)
 434          * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
 435         DumpBits( &p_vpar->bit_stream, 1 );
 436     }
 437 }
 438
 439 /*****************************************************************************
 440  * vpar_DecodeMPEG1Intra : decode MPEG-1 intra blocks
 441  *****************************************************************************/
 442 static void vpar_DecodeMPEG1Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 443 {
 444     /* À pomper dans Berkeley. */
 445
 446     if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
 447     {
 448         /* Remove end_of_macroblock (always 1, prevents startcode emulation)
 449          * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
 450         DumpBits( &p_vpar->bit_stream, 1 );
 451     }
 452 }
 453
 454 /*****************************************************************************
 455  * vpar_DecodeMPEG2Non : decode MPEG-2 non-intra blocks
 456  *****************************************************************************/
 457 static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 458 {
 459     /* À pomper dans Berkeley. Bien sûr les matrices seront différentes... */
 460 }
 461
 462 /*****************************************************************************
 463  * vpar_DecodeMPEG2Intra : decode MPEG-2 intra blocks
 464  *****************************************************************************/
 465 static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
 466 {
 467     /* À pomper dans Berkeley. */
 468 }