git.sesse.net Git - vlc/blob - modules/codec/mpeg_video/parser.h

   1 /*****************************************************************************
   2  * parser.h : video parser thread
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: parser.h,v 1.3 2003/02/04 11:51:21 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( vpar_thread_t * p_vpar );
  64
  65 typedef void (*f_picture_data_t)( vpar_thread_t * p_vpar );
  66 #define PROTO_PICD( FUNCNAME )                                              \
  67 void FUNCNAME( vpar_thread_t * 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     vlc_bool_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;              /* 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     vlc_bool_t          b_chroma_h_subsampled, b_chroma_v_subsampled;
 121     int                 i_frame_rate;  /* theoritical frame rate in fps*1001 */
 122     vlc_bool_t          b_mpeg2;                                    /* guess */
 123     vlc_bool_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     vlc_bool_t          b_expect_discontinuity; /* reset the frame predictors
 135                                                  * after the current frame   */
 136     vlc_bool_t          b_after_sequence_header; /* is it the next frame after
 137                                                   * the sequence header ?    */
 138
 139     /* Copyright extension */
 140     vlc_bool_t          b_copyright_flag;     /* Whether the following
 141                                                  information is significant
 142                                                  or not. */
 143     u8                  i_copyright_id;
 144     vlc_bool_t          b_original;
 145     u64                 i_copyright_nb;
 146 } sequence_t;
 147
 148 /*****************************************************************************
 149  * picture_parsing_t : parser context descriptor
 150  *****************************************************************************
 151  * This structure should only be changed when reading the picture header.
 152  *****************************************************************************/
 153 typedef struct picture_parsing_s
 154 {
 155     /* Values from the picture_coding_extension. */
 156     int                 ppi_f_code[2][2];
 157     int                 i_intra_dc_precision;
 158     vlc_bool_t          b_frame_pred_frame_dct, b_q_scale_type;
 159     vlc_bool_t          b_intra_vlc_format;
 160     vlc_bool_t          b_progressive;
 161     u8 *                pi_scan;
 162     vlc_bool_t          b_top_field_first, b_concealment_mv;
 163     vlc_bool_t          b_repeat_first_field;
 164     /* Relative to the current field */
 165     int                 i_coding_type, i_structure, i_field_width;
 166     vlc_bool_t          b_frame_structure; /* i_structure == FRAME_STRUCTURE */
 167     vlc_bool_t          b_current_field;         /* i_structure == TOP_FIELD */
 168     vlc_bool_t          b_second_field;
 169
 170     picture_t *         p_picture;               /* picture buffer from vout */
 171     int                 i_current_structure;   /* current parsed structure of
 172                                                 * p_picture (second field ?) */
 173     vlc_bool_t          b_error;            /* parsing error, try to recover */
 174
 175     /* Given by the video output */
 176     int                 i_lum_stride, i_chrom_stride;
 177 } picture_parsing_t;
 178
 179 /*****************************************************************************
 180  * Standard codes
 181  *****************************************************************************/
 182 #define PICTURE_START_CODE      0x100L
 183 #define SLICE_START_CODE_MIN    0x101L
 184 #define SLICE_START_CODE_MAX    0x1AFL
 185 #define USER_DATA_START_CODE    0x1B2L
 186 #define SEQUENCE_HEADER_CODE    0x1B3L
 187 #define SEQUENCE_ERROR_CODE     0x1B4L
 188 #define EXTENSION_START_CODE    0x1B5L
 189 #define SEQUENCE_END_CODE       0x1B7L
 190 #define GROUP_START_CODE        0x1B8L
 191
 192 /* extension start code IDs */
 193 #define SEQUENCE_EXTENSION_ID                    1
 194 #define SEQUENCE_DISPLAY_EXTENSION_ID            2
 195 #define QUANT_MATRIX_EXTENSION_ID                3
 196 #define COPYRIGHT_EXTENSION_ID                   4
 197 #define SEQUENCE_SCALABLE_EXTENSION_ID           5
 198 #define PICTURE_DISPLAY_EXTENSION_ID             7
 199 #define PICTURE_CODING_EXTENSION_ID              8
 200 #define PICTURE_SPATIAL_SCALABLE_EXTENSION_ID    9
 201 #define PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID  10
 202
 203 /* scalable modes */
 204 #define SC_NONE     0
 205 #define SC_DP       1
 206 #define SC_SPAT     2
 207 #define SC_SNR      3
 208 #define SC_TEMP     4
 209
 210 /* Chroma types */
 211 #define CHROMA_NONE 0
 212 #define CHROMA_420 1
 213 #define CHROMA_422 2
 214 #define CHROMA_444 3
 215
 216 /* Pictures types */
 217 #define I_CODING_TYPE           1
 218 #define P_CODING_TYPE           2
 219 #define B_CODING_TYPE           3
 220 #define D_CODING_TYPE           4 /* MPEG-1 ONLY */
 221 /* other values are reserved */
 222
 223 /* Structures */
 224 #define TOP_FIELD               1
 225 #define BOTTOM_FIELD            2
 226 #define FRAME_STRUCTURE         3
 227
 228 /* Aspect ratio (ISO/IEC 13818-2 section 6.3.3, table 6-3) */
 229 #define AR_SQUARE_PICTURE       1                           /* square pixels */
 230 #define AR_3_4_PICTURE          2                        /* 3:4 picture (TV) */
 231 #define AR_16_9_PICTURE         3              /* 16:9 picture (wide screen) */
 232 #define AR_221_1_PICTURE        4                  /* 2.21:1 picture (movie) */
 233
 234 /*****************************************************************************
 235  * Prototypes
 236  *****************************************************************************/
 237 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar );
 238 int vpar_ParseHeader( vpar_thread_t * p_vpar );
 239
 240
 241 /*
 242  * Synchronization management
 243  */
 244
 245 /*****************************************************************************
 246  * video_synchro_t : timers for the video synchro
 247  *****************************************************************************/
 248 #define MAX_PIC_AVERAGE         8
 249
 250 /* Read the discussion on top of vpar_synchro.c for more information. */
 251 typedef struct video_synchro_s
 252 {
 253     /* synchro algorithm */
 254     int             i_type;
 255
 256     /* date of the beginning of the decoding of the current picture */
 257     mtime_t         decoding_start;
 258
 259     /* stream properties */
 260     unsigned int    i_n_p, i_n_b;
 261
 262     /* decoding values */
 263     mtime_t         p_tau[4];                  /* average decoding durations */
 264     unsigned int    pi_meaningful[4];            /* number of durations read */
 265     /* and p_vout->render_time (read with p_vout->change_lock) */
 266
 267     /* stream context */
 268     unsigned int    i_eta_p, i_eta_b;
 269     vlc_bool_t      b_dropped_last;            /* for special synchros below */
 270     mtime_t         backward_pts, current_pts;
 271     int             i_current_period;   /* period to add to the next picture */
 272     int             i_backward_period;  /* period to add after the next
 273                                          * reference picture
 274                                          * (backward_period * period / 2) */
 275
 276     /* statistics */
 277     unsigned int    i_trashed_pic, i_not_chosen_pic, i_pic;
 278 } video_synchro_t;
 279
 280 /* Synchro algorithms */
 281 #define VPAR_SYNCHRO_DEFAULT    0
 282 #define VPAR_SYNCHRO_I          1
 283 #define VPAR_SYNCHRO_Iplus      2
 284 #define VPAR_SYNCHRO_IP         3
 285 #define VPAR_SYNCHRO_IPplus     4
 286 #define VPAR_SYNCHRO_IPB        5
 287
 288 /*****************************************************************************
 289  * Prototypes
 290  *****************************************************************************/
 291 void vpar_SynchroInit           ( vpar_thread_t * p_vpar );
 292 vlc_bool_t vpar_SynchroChoose   ( vpar_thread_t * p_vpar, int, int );
 293 void vpar_SynchroTrash          ( vpar_thread_t * p_vpar, int, int );
 294 void vpar_SynchroDecode         ( vpar_thread_t * p_vpar, int, int );
 295 void vpar_SynchroEnd            ( vpar_thread_t * p_vpar, int, int, int );
 296 mtime_t vpar_SynchroDate        ( vpar_thread_t * p_vpar );
 297 void vpar_SynchroNewPicture     ( vpar_thread_t * p_vpar, int, int );
 298
 299 /*
 300  * Video parser structures
 301  */
 302
 303 /*****************************************************************************
 304  * vpar_thread_t: video parser thread descriptor
 305  *****************************************************************************/
 306 struct vpar_thread_t
 307 {
 308     bit_stream_t            bit_stream;
 309
 310     /* Thread properties and locks */
 311     vlc_thread_t            thread_id;            /* id for thread functions */
 312
 313     /* Input properties */
 314     decoder_fifo_t *        p_fifo;                        /* PES input fifo */
 315
 316     /* Output properties */
 317     vout_thread_t *         p_vout;                   /* video output thread */
 318
 319     /* Decoder properties */
 320     vdec_pool_t             pool;
 321
 322     /* Parser properties */
 323     sequence_t              sequence;
 324     picture_parsing_t       picture;
 325     macroblock_parsing_t    mb;
 326     video_synchro_t         synchro;
 327
 328     /* Scan table */
 329     u8                      ppi_scan[2][64];
 330     /* Default quantization matrices */
 331     u8                      pi_default_intra_quant[64];
 332     u8                      pi_default_nonintra_quant[64];
 333
 334     /* Motion compensation plug-in used and shortcuts */
 335     module_t *       p_motion;
 336
 337     /* IDCT plug-in used and shortcuts */
 338     module_t *       p_idct;
 339     void ( * pf_sparse_idct_add )( dctelem_t *, yuv_data_t *, int,
 340                                  void *, int );
 341     void ( * pf_idct_add )     ( dctelem_t *, yuv_data_t *, int,
 342                                  void *, int );
 343     void ( * pf_sparse_idct_copy )( dctelem_t *, yuv_data_t *, int,
 344                                   void *, int );
 345     void ( * pf_idct_copy )    ( dctelem_t *, yuv_data_t *, int,
 346                                  void *, int );
 347
 348     void ( * pf_norm_scan ) ( u8 ppi_scan[2][64] );
 349
 350     /* Statistics */
 351     count_t         c_loops;                              /* number of loops */
 352     count_t         c_sequences;                      /* number of sequences */
 353     count_t         pc_pictures[4]; /* number of (coding_type) pictures read */
 354     count_t         pc_decoded_pictures[4];       /* number of (coding_type)
 355                                                    *        pictures decoded */
 356     count_t         pc_malformed_pictures[4];  /* number of pictures trashed
 357                                                 * during parsing             */
 358 };
 359
 360 /*****************************************************************************
 361  * NextStartCode : Find the next start code
 362  *****************************************************************************/
 363 static inline void NextStartCode( bit_stream_t * p_bit_stream )
 364 {
 365     /* Re-align the buffer on an 8-bit boundary */
 366     RealignBits( p_bit_stream );
 367
 368     while( ShowBits( p_bit_stream, 24 ) != 0x01L
 369             && !p_bit_stream->p_decoder_fifo->b_die )
 370     {
 371         RemoveBits( p_bit_stream, 8 );
 372     }
 373 }
 374
 375 /*****************************************************************************
 376  * LoadQuantizerScale
 377  *****************************************************************************
 378  * Quantizer scale factor (ISO/IEC 13818-2 7.4.2.2)
 379  *****************************************************************************/
 380 static inline void LoadQuantizerScale( vpar_thread_t * p_vpar )
 381 {
 382     /* Quantization coefficient table */
 383     static u8   pi_non_linear_quantizer_scale[32] =
 384     {
 385         0, 1, 2, 3, 4, 5, 6, 7, 8, 10,12,14,16,18,20, 22,
 386         24,28,32,36,40,44,48,52,56,64,72,80,88,96,104,112
 387     };
 388     int         i_q_scale_code = GetBits( &p_vpar->bit_stream, 5 );
 389
 390     if( p_vpar->picture.b_q_scale_type )
 391     {
 392         p_vpar->mb.i_quantizer_scale =
 393                         pi_non_linear_quantizer_scale[i_q_scale_code];
 394     }
 395     else
 396     {
 397         p_vpar->mb.i_quantizer_scale = i_q_scale_code << 1;
 398     }
 399 }
 400