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