git.sesse.net Git - vlc/blob - src/video_decoder/video_parser.h

   1 /*****************************************************************************
   2  * video_parser.h : video parser thread
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: video_parser.h,v 1.16 2001/10/11 13:19:27 massiot Exp $
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *          Jean-Marc Dressler <polux@via.ecp.fr>
   9  *          Stéphane Borel <stef@via.ecp.fr>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24  *****************************************************************************/
  25
  26 /*
  27  * Block parsing structures
  28  */
  29
  30 /*****************************************************************************
  31  * macroblock_parsing_t : macroblock context & predictors
  32  *****************************************************************************/
  33 typedef struct motion_s
  34 {
  35     u8 *                pppi_ref[2][3];
  36     int                 ppi_pmv[2][2];
  37     int                 pi_f_code[2];
  38 } motion_t;
  39
  40 typedef struct macroblock_parsing_s
  41 {
  42     int                 i_offset;
  43
  44     motion_t            b_motion;
  45     motion_t            f_motion;
  46
  47     /* Predictor for DC coefficients in intra blocks */
  48     u16                 pi_dc_dct_pred[3];
  49     u8                  i_quantizer_scale;        /* scale of the quantization
  50                                                    * matrices                */
  51 } macroblock_parsing_t;
  52
  53 /*****************************************************************************
  54  * Constants
  55  *****************************************************************************/
  56 extern u8       pi_default_intra_quant[64];
  57 extern u8       pi_default_nonintra_quant[64];
  58 extern u8       pi_scan[2][64];
  59
  60 /*****************************************************************************
  61  * Prototypes
  62  *****************************************************************************/
  63 void vpar_InitScanTable( struct vpar_thread_s * p_vpar );
  64
  65 typedef void (*f_picture_data_t)( struct vpar_thread_s * p_vpar );
  66 #define PROTO_PICD( FUNCNAME )                                              \
  67 void FUNCNAME( struct vpar_thread_s * p_vpar );
  68
  69 PROTO_PICD( vpar_PictureDataGENERIC )
  70 #if (VPAR_OPTIM_LEVEL > 0)
  71 PROTO_PICD( vpar_PictureData2IF )
  72 PROTO_PICD( vpar_PictureData2PF )
  73 PROTO_PICD( vpar_PictureData2BF )
  74 #endif
  75 #if (VPAR_OPTIM_LEVEL > 1)
  76 PROTO_PICD( vpar_PictureData2IT )
  77 PROTO_PICD( vpar_PictureData2PT )
  78 PROTO_PICD( vpar_PictureData2BT )
  79 PROTO_PICD( vpar_PictureData2IB )
  80 PROTO_PICD( vpar_PictureData2PB )
  81 PROTO_PICD( vpar_PictureData2BB )
  82 PROTO_PICD( vpar_PictureData1I )
  83 PROTO_PICD( vpar_PictureData1P )
  84 PROTO_PICD( vpar_PictureData1B )
  85 PROTO_PICD( vpar_PictureData1D )
  86 #endif
  87
  88
  89 /*
  90  * Headers parsing structures
  91  */
  92
  93 /*****************************************************************************
  94  * quant_matrix_t : Quantization Matrix
  95  *****************************************************************************/
  96 typedef struct quant_matrix_s
  97 {
  98     u8 *        pi_matrix;
  99     boolean_t   b_allocated;
 100                           /* Has the matrix been allocated by vpar_headers ? */
 101 } quant_matrix_t;
 102
 103 /*****************************************************************************
 104  * sequence_t : sequence descriptor
 105  *****************************************************************************
 106  * This structure should only be changed when reading the sequence header,
 107  * or exceptionnally some extension structures (like quant_matrix).
 108  *****************************************************************************/
 109 typedef struct sequence_s
 110 {
 111     u32                 i_height, i_width;      /* height and width of the lum
 112                                                  * comp of the picture       */
 113     u32                 i_size;       /* total number of pel of the lum comp */
 114     u32                 i_mb_height, i_mb_width, i_mb_size;
 115                                             /* the same, in macroblock units */
 116     unsigned int        i_aspect_ratio;        /* height/width display ratio */
 117     unsigned int        i_matrix_coefficients;/* coeffs of the YUV transform */
 118     int                 i_chroma_format, i_scalable_mode;
 119     int                 i_chroma_nb_blocks;
 120     boolean_t           b_chroma_h_subsampled, b_chroma_v_subsampled;
 121     int                 i_frame_rate;  /* theoritical frame rate in fps*1001 */
 122     boolean_t           b_mpeg2;                                    /* guess */
 123     boolean_t           b_progressive;              /* progressive (ie.
 124                                                      * non-interlaced) frame */
 125     quant_matrix_t      intra_quant, nonintra_quant;
 126     quant_matrix_t      chroma_intra_quant, chroma_nonintra_quant;
 127                                             /* current quantization matrices */
 128
 129     /* Parser context */
 130     picture_t *         p_forward;        /* current forward reference frame */
 131     picture_t *         p_backward;      /* current backward reference frame */
 132     mtime_t             next_pts, next_dts;
 133     int                 i_current_rate;
 134     boolean_t           b_expect_discontinuity; /* reset the frame predictors
 135                                                  * after the current frame   */
 136
 137     /* Copyright extension */
 138     boolean_t           b_copyright_flag;     /* Whether the following
 139                                                  information is significant
 140                                                  or not. */
 141     u8                  i_copyright_id;
 142     boolean_t           b_original;
 143     u64                 i_copyright_nb;
 144 } sequence_t;
 145
 146 /*****************************************************************************
 147  * picture_parsing_t : parser context descriptor
 148  *****************************************************************************
 149  * This structure should only be changed when reading the picture header.
 150  *****************************************************************************/
 151 typedef struct picture_parsing_s
 152 {
 153     /* Values from the picture_coding_extension. */
 154     int                 ppi_f_code[2][2];
 155     int                 i_intra_dc_precision;
 156     boolean_t           b_frame_pred_frame_dct, b_q_scale_type;
 157     boolean_t           b_intra_vlc_format;
 158     boolean_t           b_progressive;
 159     u8 *                pi_scan;
 160     boolean_t           b_top_field_first, b_concealment_mv;
 161     boolean_t           b_repeat_first_field;
 162     /* Relative to the current field */
 163     int                 i_coding_type, i_structure;
 164     boolean_t           b_frame_structure; /* i_structure == FRAME_STRUCTURE */
 165     boolean_t           b_current_field;         /* i_structure == TOP_FIELD */
 166     boolean_t           b_second_field;
 167
 168     picture_t *         p_picture;               /* picture buffer from vout */
 169     int                 i_current_structure;   /* current parsed structure of
 170                                                 * p_picture (second field ?) */
 171     int                 i_field_width;
 172     boolean_t           b_error;            /* parsing error, try to recover */
 173 } picture_parsing_t;
 174
 175 /*****************************************************************************
 176  * Standard codes
 177  *****************************************************************************/
 178 #define PICTURE_START_CODE      0x100L
 179 #define SLICE_START_CODE_MIN    0x101L
 180 #define SLICE_START_CODE_MAX    0x1AFL
 181 #define USER_DATA_START_CODE    0x1B2L
 182 #define SEQUENCE_HEADER_CODE    0x1B3L
 183 #define SEQUENCE_ERROR_CODE     0x1B4L
 184 #define EXTENSION_START_CODE    0x1B5L
 185 #define SEQUENCE_END_CODE       0x1B7L
 186 #define GROUP_START_CODE        0x1B8L
 187
 188 /* extension start code IDs */
 189 #define SEQUENCE_EXTENSION_ID                    1
 190 #define SEQUENCE_DISPLAY_EXTENSION_ID            2
 191 #define QUANT_MATRIX_EXTENSION_ID                3
 192 #define COPYRIGHT_EXTENSION_ID                   4
 193 #define SEQUENCE_SCALABLE_EXTENSION_ID           5
 194 #define PICTURE_DISPLAY_EXTENSION_ID             7
 195 #define PICTURE_CODING_EXTENSION_ID              8
 196 #define PICTURE_SPATIAL_SCALABLE_EXTENSION_ID    9
 197 #define PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID  10
 198
 199 /* scalable modes */
 200 #define SC_NONE     0
 201 #define SC_DP       1
 202 #define SC_SPAT     2
 203 #define SC_SNR      3
 204 #define SC_TEMP     4
 205
 206 /* Chroma types */
 207 #define CHROMA_NONE 0
 208 #define CHROMA_420 1
 209 #define CHROMA_422 2
 210 #define CHROMA_444 3
 211
 212 /* Pictures types */
 213 #define I_CODING_TYPE           1
 214 #define P_CODING_TYPE           2
 215 #define B_CODING_TYPE           3
 216 #define D_CODING_TYPE           4 /* MPEG-1 ONLY */
 217 /* other values are reserved */
 218
 219 /* Structures */
 220 #define TOP_FIELD               1
 221 #define BOTTOM_FIELD            2
 222 #define FRAME_STRUCTURE         3
 223
 224 /*****************************************************************************
 225  * Prototypes
 226  *****************************************************************************/
 227 int vpar_NextSequenceHeader( struct vpar_thread_s * p_vpar );
 228 int vpar_ParseHeader( struct vpar_thread_s * p_vpar );
 229
 230
 231 /*
 232  * Synchronization management
 233  */
 234
 235 /*****************************************************************************
 236  * video_synchro_t : timers for the video synchro
 237  *****************************************************************************/
 238 #define MAX_PIC_AVERAGE         8
 239
 240 /* Read the discussion on top of vpar_synchro.c for more information. */
 241 typedef struct video_synchro_s
 242 {
 243     /* synchro algorithm */
 244     int             i_type;
 245
 246     /* date of the beginning of the decoding of the current picture */
 247     mtime_t         decoding_start;
 248
 249     /* stream properties */
 250     unsigned int    i_n_p, i_n_b;
 251
 252     /* decoding values */
 253     mtime_t         p_tau[4];                  /* average decoding durations */
 254     unsigned int    pi_meaningful[4];            /* number of durations read */
 255     /* and p_vout->render_time (read with p_vout->change_lock) */
 256
 257     /* stream context */
 258     unsigned int    i_eta_p, i_eta_b;
 259     boolean_t       b_dropped_last;            /* for special synchros below */
 260     mtime_t         backward_pts, current_pts;
 261     int             i_current_period;   /* period to add to the next picture */
 262     int             i_backward_period;  /* period to add after the next
 263                                          * reference picture
 264                                          * (backward_period * period / 2) */
 265
 266     /* statistics */
 267     unsigned int    i_trashed_pic, i_not_chosen_pic, i_pic;
 268 } video_synchro_t;
 269
 270 /* Synchro algorithms */
 271 #define VPAR_SYNCHRO_DEFAULT    0
 272 #define VPAR_SYNCHRO_I          1
 273 #define VPAR_SYNCHRO_Iplus      2
 274 #define VPAR_SYNCHRO_IP         3
 275 #define VPAR_SYNCHRO_IPplus     4
 276 #define VPAR_SYNCHRO_IPB        5
 277
 278 /*****************************************************************************
 279  * Prototypes
 280  *****************************************************************************/
 281 void vpar_SynchroInit           ( struct vpar_thread_s * p_vpar );
 282 boolean_t vpar_SynchroChoose    ( struct vpar_thread_s * p_vpar,
 283                                   int i_coding_type, int i_structure );
 284 void vpar_SynchroTrash          ( struct vpar_thread_s * p_vpar,
 285                                   int i_coding_type, int i_structure );
 286 void vpar_SynchroDecode         ( struct vpar_thread_s * p_vpar,
 287                                   int i_coding_type, int i_structure );
 288 void vpar_SynchroEnd            ( struct vpar_thread_s * p_vpar,
 289                                   int i_coding_type, int i_structure,
 290                                   int i_garbage );
 291 mtime_t vpar_SynchroDate        ( struct vpar_thread_s * p_vpar );
 292 void vpar_SynchroNewPicture( struct vpar_thread_s * p_vpar, int i_coding_type,
 293                              int i_repeat_field );
 294
 295
 296 /*
 297  * Video parser structures
 298  */
 299
 300 /*****************************************************************************
 301  * vpar_thread_t: video parser thread descriptor
 302  *****************************************************************************/
 303 typedef struct vpar_thread_s
 304 {
 305     bit_stream_t            bit_stream;
 306
 307     /* Thread properties and locks */
 308     vlc_thread_t            thread_id;            /* id for thread functions */
 309
 310     /* Input properties */
 311     decoder_fifo_t *        p_fifo;                        /* PES input fifo */
 312     vdec_config_t *         p_config;
 313
 314     /* Output properties */
 315     vout_thread_t *         p_vout;                   /* video output thread */
 316
 317     /* Decoder properties */
 318     vdec_pool_t             pool;
 319
 320     /* Parser properties */
 321     sequence_t              sequence;
 322     picture_parsing_t       picture;
 323     macroblock_parsing_t    mb;
 324     video_synchro_t         synchro;
 325
 326     /* Scan table */
 327     u8                      ppi_scan[2][64];
 328     /* Default quantization matrices */
 329     u8                      pi_default_intra_quant[64];
 330     u8                      pi_default_nonintra_quant[64];
 331
 332     /* Motion compensation plug-in used and shortcuts */
 333     struct module_s *       p_motion_module;
 334
 335     /* IDCT plug-in used and shortcuts */
 336     struct module_s *       p_idct_module;
 337     void ( * pf_sparse_idct_add )( dctelem_t *, yuv_data_t *, int,
 338                                  void *, int );
 339     void ( * pf_idct_add )     ( dctelem_t *, yuv_data_t *, int,
 340                                  void *, int );
 341     void ( * pf_sparse_idct_copy )( dctelem_t *, yuv_data_t *, int,
 342                                   void *, int );
 343     void ( * pf_idct_copy )    ( dctelem_t *, yuv_data_t *, int,
 344                                  void *, int );
 345
 346     void ( * pf_norm_scan ) ( u8 ppi_scan[2][64] );
 347
 348     /* Statistics */
 349     count_t         c_loops;                              /* number of loops */
 350     count_t         c_sequences;                      /* number of sequences */
 351     count_t         pc_pictures[4]; /* number of (coding_type) pictures read */
 352     count_t         pc_decoded_pictures[4];       /* number of (coding_type)
 353                                                    *        pictures decoded */
 354     count_t         pc_malformed_pictures[4];  /* number of pictures trashed
 355                                                 * during parsing             */
 356 } vpar_thread_t;
 357
 358 /*****************************************************************************
 359  * NextStartCode : Find the next start code
 360  *****************************************************************************/
 361 static __inline__ void NextStartCode( bit_stream_t * p_bit_stream )
 362 {
 363     /* Re-align the buffer on an 8-bit boundary */
 364     RealignBits( p_bit_stream );
 365
 366     while( ShowBits( p_bit_stream, 24 ) != 0x01L
 367             && !p_bit_stream->p_decoder_fifo->b_die )
 368     {
 369         RemoveBits( p_bit_stream, 8 );
 370     }
 371 }
 372
 373 /*****************************************************************************
 374  * LoadQuantizerScale
 375  *****************************************************************************
 376  * Quantizer scale factor (ISO/IEC 13818-2 7.4.2.2)
 377  *****************************************************************************/
 378 static __inline__ void LoadQuantizerScale( struct vpar_thread_s * p_vpar )
 379 {
 380     /* Quantization coefficient table */
 381     static u8   pi_non_linear_quantizer_scale[32] =
 382     {
 383         0, 1, 2, 3, 4, 5, 6, 7, 8, 10,12,14,16,18,20, 22,
 384         24,28,32,36,40,44,48,52,56,64,72,80,88,96,104,112
 385     };
 386     int         i_q_scale_code = GetBits( &p_vpar->bit_stream, 5 );
 387
 388     if( p_vpar->picture.b_q_scale_type )
 389     {
 390         p_vpar->mb.i_quantizer_scale =
 391                         pi_non_linear_quantizer_scale[i_q_scale_code];
 392     }
 393     else
 394     {
 395         p_vpar->mb.i_quantizer_scale = i_q_scale_code << 1;
 396     }
 397 }
 398