git.sesse.net Git - vlc/blob - src/video_parser/vpar_headers.c

   1 /*****************************************************************************
   2  * vpar_headers.c : headers 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 "vpar_blocks.h"
  32 #include "video_parser.h"
  33
  34 #include "macroblock.h"
  35 #include "video_fifo.h"
  36 #include "video_decoder.h"
  37
  38 /*
  39  * Local prototypes
  40  */
  41 static __inline__ void NextStartCode( vpar_thread_t * p_vpar );
  42 static void GroupHeader( vpar_thread_t * p_vpar )
  43 static void PictureHeader( vpar_thread_t * p_vpar )
  44 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
  45                                         int i_coding_type,
  46                                         picture_t * p_newref )
  47 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
  48                                          int i_coding_type,
  49                                          picture_t * p_newref )
  50 static void SliceHeader00( vpar_thread_t * p_vpar,
  51                            int * pi_mb_address, int i_mb_base,
  52                            elem_t * p_y, p_u, p_v, u32 i_vert_code )
  53 static void SliceHeader01( vpar_thread_t * p_vpar,
  54                            int * pi_mb_address, int i_mb_base,
  55                            elem_t * p_y, p_u, p_v, u32 i_vert_code )
  56 static void SliceHeader10( vpar_thread_t * p_vpar,
  57                            int * pi_mb_address, int i_mb_base,
  58                            elem_t * p_y, p_u, p_v, u32 i_vert_code )
  59 static void SliceHeader11( vpar_thread_t * p_vpar,
  60                            int * pi_mb_address, int i_mb_base,
  61                            elem_t * p_y, p_u, p_v, u32 i_vert_code )
  62 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
  63                                     int * pi_mb_address, int i_mb_base,
  64                                     elem_t * p_y, p_u, p_v, u32 i_vert_code )
  65 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
  66
  67 /*****************************************************************************
  68  * vpar_NextSequenceHeader : Find the next sequence header
  69  *****************************************************************************/
  70 void vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
  71 {
  72     while( !p_vpar->b_die )
  73     {
  74         NextStartCode( p_vpar );
  75         if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_START_CODE )
  76             return;
  77     }
  78 }
  79
  80 /*****************************************************************************
  81  * vpar_ParseHeader : Parse the next header
  82  *****************************************************************************/
  83 int vpar_ParseHeader( vpar_thread_t * p_vpar )
  84 {
  85     while( !p_vpar->b_die )
  86     {
  87         NextStartCode( p_vpar );
  88         switch( GetBits32( &p_vpar->bit_stream ) )
  89         {
  90         case SEQUENCE_HEADER_CODE:
  91             SequenceHeader( p_vpar );
  92             return 0;
  93             break;
  94
  95         case GROUP_START_CODE:
  96             GroupHeader( p_vpar );
  97             return 0;
  98             break;
  99
 100         case PICTURE_START_CODE:
 101             PictureHeader( p_vpar );
 102             return 0;
 103             break;
 104
 105         case SEQUENCE_END_CODE:
 106             return 1;
 107             break;
 108
 109         default:
 110         }
 111     }
 112
 113     return 0;
 114 }
 115
 116 /*
 117  * Following functions are local
 118  */
 119
 120 /*****************************************************************************
 121  * NextStartCode : Find the next start code
 122  *****************************************************************************/
 123 static __inline__ void NextStartCode( vpar_thread_t * p_vpar )
 124 {
 125     /* Re-align the buffer on an 8-bit boundary */
 126     DumpBits( &p_vpar->bit_stream, p_vpar->bit_stream.fifo.i_available & 7 );
 127
 128     while( ShowBits( &p_vpar->bit_stream, 24 ) != 0x01L && !p_vpar->b_die )
 129     {
 130         DumpBits( &p_vpar->bit_stream, 8 );
 131     }
 132 }
 133
 134 /*****************************************************************************
 135  * SequenceHeader : Parse the next sequence header
 136  *****************************************************************************/
 137 static void SequenceHeader( vpar_thread_t * p_vpar )
 138 {
 139 #define RESERVED    -1
 140     static double d_frame_rate_table[16] =
 141     {
 142         0.0,
 143         ((23.0*1000.0)/1001.0),
 144         24.0,
 145         25.0,
 146         ((30.0*1000.0)/1001.0),
 147         30.0,
 148         50.0,
 149         ((60.0*1000.0)/1001.0),
 150         60.0,
 151         RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
 152     };
 153 #undef RESERVED
 154
 155     int i_height_save, i_width_save;
 156
 157     i_height_save = p_vpar->sequence.i_height;
 158     i_width_save = p_vpar->sequence.i_width;
 159
 160     p_vpar->sequence.i_height = GetBits( p_vpar->bit_stream, 12 );
 161     p_vpar->sequence.i_width = GetBits( p_vpar->bit_stream, 12 );
 162     p_vpar->sequence.i_ratio = GetBits( p_vpar->bit_stream, 4 );
 163     p_vpar->sequence.d_frame_rate =
 164             d_frame_rate_table( GetBits( p_vpar->bit_stream, 4 ) );
 165
 166     /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
 167      * constrained_parameters_flag */
 168     DumpBits( p_vpar->bit_stream, 30 );
 169
 170     /*
 171      * Quantization matrices
 172      */
 173     if( GetBits( p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
 174     {
 175         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 176     }
 177     else
 178     {
 179         /* Use default matrix. */
 180         LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
 181     }
 182
 183     if( GetBits( p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
 184     {
 185         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 186     }
 187     else
 188     {
 189         /* Use default matrix. */
 190         LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
 191     }
 192
 193     /* Unless later overwritten by a matrix extension, we have the same
 194      * matrices for luminance and chrominance. */
 195     LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 196                 p_vpar->sequence.intra_quant.pi_matrix );
 197     LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 198                 p_vpar->sequence.nonintra_quant.pi_matrix );
 199
 200     /*
 201      * Sequence Extension
 202      */
 203     NextStartCode( p_vpar );
 204     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
 205     {
 206         int             i_dummy;
 207         static int      pi_chroma_nb_blocks[4] = {0, 1, 2, 4};
 208         static (void *) ppf_chroma_pattern[4]( vpar_thread_t * ) =
 209                             {NULL, vpar_CodedPattern420,
 210                              vpar_CodedPattern422, vpar_CodedPattern444};
 211
 212         /* Parse sequence_extension */
 213         DumpBits32( &p_vpar->bit_stream );
 214         /* extension_start_code_identifier, profile_and_level_indication */
 215         DumpBits( &p_vpar->bit_stream, 12 );
 216         p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
 217         p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
 218         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width
 219                     >> (3-p_vpar->sequence.i_chroma_format);
 220         p_vpar->sequence.i_chroma_nb_blocks = pi_chroma_nb_blocks
 221                                     [p_vpar->sequence.i_chroma_format];
 222         p_vpar->sequence.pf_decode_pattern = ppf_chroma_pattern
 223                                     [p_vpar->sequence.i_chroma_format];
 224         p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
 225         p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
 226         /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
 227         DumpBits( &p_vpar->bit_stream, 22 );
 228         /* frame_rate_extension_n */
 229         i_dummy = GetBits( &p_vpar->bit_stream, 2 );
 230         /* frame_rate_extension_d */
 231         p_vpar->sequence.d_frame_rate *= (i_dummy + 1)
 232                                   / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
 233
 234         p_vpar->sequence.pf_decode_mv = vpar_MPEG2MotionVector;
 235     }
 236     else
 237     {
 238         /* It's an MPEG-1 stream. Put adequate parameters. */
 239         p_vpar->sequence.b_progressive = 1;
 240         p_vpar->sequence.i_chroma_format = CHROMA_420;
 241         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i->width >> 2;
 242         p_vpar->sequence.i_chroma_nb_blocks = 2;
 243         p_vpar->sequence.pf_decode_pattern = vpar_CodedPattern420;
 244
 245         p_vpar->sequence.pf_decode_mv = vpar_MPEG1MotionVector;
 246     }
 247
 248     p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
 249     p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
 250                                    (p_vpar->sequence.i_height + 15) / 16 :
 251                                    2 * (p_vpar->sequence.i_height + 31) / 32;
 252     p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
 253                                         * p_vpar->sequence.i_mb_height;
 254     p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
 255     p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
 256     p_vpar->sequence.i_size = p_vpar->sequence.i_width
 257                                         * p_vpar->sequence.i_height;
 258
 259     /* Slice Header functions */
 260     if( p_vpar->sequence.i_height <= 2800 )
 261     {
 262         if( p_vpar->sequence.i_scalable_mode != SC_DP )
 263         {
 264             p_vpar->sequence.pf_slice_header = SliceHeader00;
 265         }
 266         else
 267         {
 268             p_vpar->sequence.pf_slice_header = SliceHeader01;
 269         }
 270     }
 271     else
 272     {
 273         if( p_vpar->sequence.i_scalable_mode != SC_DP )
 274         {
 275             p_vpar->sequence.pf_slice_header = SliceHeader10;
 276         }
 277         else
 278         {
 279             p_vpar->sequence.pf_slice_header = SliceHeader11;
 280         }
 281     }
 282
 283     if(    p_vpar->sequence.i_width != i_width_save
 284         || p_vpar->sequence.i_height != i_height_save
 285         || p_vpar->sequence.p_frame_lum_lookup == NULL )
 286     {
 287
 288     }
 289
 290     /* Extension and User data */
 291     ExtensionAndUserData( p_vpar );
 292 }
 293
 294 /*****************************************************************************
 295  * GroupHeader : Parse the next group of pictures header
 296  *****************************************************************************/
 297 static void GroupHeader( vpar_thread_t * p_vpar )
 298 {
 299     /* Nothing to do, we don't care. */
 300     DumpBits( &p_vpar->bit_stream, 27 );
 301     ExtensionAndUserData( p_vpar );
 302 }
 303
 304 /*****************************************************************************
 305  * PictureHeader : Parse the next picture header
 306  *****************************************************************************/
 307 static void PictureHeader( vpar_thread_t * p_vpar )
 308 {
 309     static (int *)      ppf_macroblock_type[4] = {vpar_IMBType, vpar_PMBType,
 310                                                   vpar_BMBType, vpar_DMBType};
 311
 312     int                 i_structure;
 313     int                 i_mb_address, i_mb_base, i_mb;
 314     elem_t *            p_y, p_u, p_v;
 315     boolean_t           b_parsable;
 316     u32                 i_dummy;
 317
 318     DumpBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
 319     p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
 320     p_vpar->picture.pf_macroblock_type = ppf_macroblock_type
 321                                          [p_vpar->picture.i_coding_type];
 322
 323     DumpBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
 324
 325     p_vpar->picture.b_full_pel_forward_vector = GetBits( &p_vpar->bit_stream, 1 );
 326     p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
 327     p_vpar->picture.b_full_pel_backward_vector = GetBits( &p_vpar->bit_stream, 1 );
 328     p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
 329
 330     /* extra_information_picture */
 331     while( GetBits( &p_vpar->bit_stream, 1 ) )
 332     {
 333         DumpBits( &p_vpar->bit_stream, 8 );
 334     }
 335
 336     /*
 337      * Picture Coding Extension
 338      */
 339     NextStartCode( p_vpar );
 340     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
 341     {
 342         /* Parse picture_coding_extension */
 343         DumpBits32( &p_vpar->bit_stream );
 344         /* extension_start_code_identifier */
 345         DumpBits( &p_vpar->bit_stream, 4 );
 346
 347         p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
 348         p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
 349         p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
 350         p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
 351         p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
 352         i_structure = GetBits( &p_vpar->bit_stream, 2 );
 353         p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
 354         p_vpar->picture.b_frame_pred_frame_dct
 355              = GetBits( &p_vpar->bit_stream, 1 );
 356         p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
 357         p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
 358         p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
 359         p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
 360         p_vpar->picture.b_repeat_first_field = GetBits( &vpar->bit_stream, 1 );
 361         /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
 362          * the length of the picture_display_extension structure.
 363          * chroma_420_type (obsolete) */
 364         DumpBits( &p_vpar->bit_stream, 1 );
 365         p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
 366
 367         /* composite_display_flag */
 368         if( GetBits( &p_vpar->bit_stream, 1 ) )
 369         {
 370             /* v_axis, field_sequence, sub_carrier, burst_amplitude,
 371              * sub_carrier_phase */
 372             DumpBits( &p_vpar->bit_stream, 20 );
 373         }
 374     }
 375     else
 376     {
 377         /* MPEG-1 compatibility flags */
 378         p_vpar->i_intra_dc_precision = 0; /* 8 bits */
 379         i_structure = FRAME_STRUCTURE;
 380         p_vpar->b_frame_pred_frame_dct = TRUE;
 381         p_vpar->picture.b_concealment_mv = 0;
 382         p_vpar->picture.b_q_scale_type = 0;
 383         p_vpar->picture.b_intra_vlc_format = 0;
 384         p_vpar->picture.b_alternate_scan = 0; /* zigzag */
 385         b_repeat_first_field = FALSE;
 386         p_vpar->picture.b_progressive_frame = TRUE;
 387     }
 388
 389     if( p_vpar->picture.i_current_structure &&
 390         (i_structure == FRAME_STRUCTURE ||
 391          i_structure == p_vpar->picture.i_current_structure) )
 392     {
 393         /* We don't have the second field of the buffered frame. */
 394         if( p_pvar->picture.p_picture != NULL )
 395         {
 396             ReferenceReplace( p_vpar,
 397                       p_vpar->picture.p_second_field_buffer->i_coding_type,
 398                       NULL );
 399
 400             for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size >> 1; i_mb++ )
 401             {
 402                 vpar_DestroyMacroblock( &p_vpar->vfifo,
 403                                         p_vpar->picture.pp_mb[i_mb] );
 404             }
 405             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
 406         }
 407
 408         p_pvar->picture.i_current_structure = 0;
 409
 410         intf_DbgMsg("vpar debug: odd number of field picture.");
 411     }
 412
 413     if( p_vpar->picture.i_current_structure )
 414     {
 415         /* Second field of a frame. We will decode it if, and only if we
 416          * have decoded the first frame. */
 417         b_parsable = (p_vpar->picture.p_second_field_buffer != NULL);
 418     }
 419     else
 420     {
 421         /* Do we have the reference pictures ? */
 422         b_parsable = !((i_coding_type == P_CODING_TYPE) &&
 423                        (p_vpar->sequence.p_forward == NULL)) ||
 424                       ((i_coding_type == B_CODING_TYPE) &&
 425                        (p_vpar->sequence.p_forward == NULL ||
 426                         p_vpar->sequence.p_backward == NULL));
 427
 428         /* Does synchro say we have enough time to decode it ? */
 429         b_parsable &&= vpar_SynchroChoose( p_vpar, i_coding_type, i_structure );
 430     }
 431
 432     if( !b_parsable )
 433     {
 434         /* Update the reference pointers. */
 435         ReferenceUpdate( p_vpar, i_coding_type, NULL );
 436
 437         /* Warn Synchro we have trashed a picture. */
 438         vpar_SynchroTrash( p_vpar, i_coding_type, i_structure );
 439
 440         /* Update context. */
 441         if( i_structure != FRAME_STRUCTURE )
 442             p_vpar->picture.i_current_structure = i_structure;
 443         p_vpar->picture.p_picture = NULL;
 444
 445         return;
 446     }
 447
 448     /* OK, now we are sure we will decode the picture. */
 449 #define P_picture p_vpar->picture.p_picture
 450     p_vpar->picture.b_error = FALSE;
 451
 452     if( !p_vpar->picture.i_current_structure )
 453     {
 454         /* This is a new frame. Get a structure from the video_output. */
 455         P_picture = vout_CreatePicture( p_vpar->p_vout,
 456                                         SPLITTED_YUV_PICTURE,
 457                                         p_vpar->sequence.i_width,
 458                                         p_vpar->sequence.i_height,
 459                                         p_vpar->sequence.i_chroma_format );
 460
 461         /* Initialize values. */
 462         P_picture->date = vpar_SynchroDecode( p_vpar, i_coding_type,
 463                                               i_structure );
 464         bzero( p_vpar->picture.pp_mb, MAX_MB*sizeof( macroblock_t * ) );
 465         p_vpar->picture.i_lum_incr = - 8 + ( p_vpar->sequence.i_width
 466                     << ( i_structure != FRAME_STRUCTURE ) );
 467         p_vpar->picture.i_chroma_incr = -8 + ( p_vpar->sequence.i_width
 468                     << (( i_structure != FRAME_STRUCTURE ) +
 469                         ( 3 - p_vpar->sequence.i_chroma_format )) );
 470
 471         /* Update the reference pointers. */
 472         ReferenceUpdate( p_vpar, i_coding_type, p_undec_p );
 473     }
 474     p_vpar->picture.i_current_structure |= i_structure;
 475     p_vpar->picture.i_structure = i_structure;
 476     p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
 477
 478     /* Initialize picture data for decoding. */
 479     if( i_structure == BOTTOM_FIELD )
 480     {
 481         i_mb_base = p_vpar->sequence.i_mb_size >> 1;
 482     }
 483     else
 484     {
 485         i_mb_base = 0;
 486     }
 487     i_mb_address = 0;
 488
 489     /* Extension and User data. */
 490     ExtensionAndUserData( p_vpar );
 491
 492     /* Picture data (ISO/IEC 13818-2 6.2.3.7). */
 493     NextStartCode( p_vpar );
 494     while( i_mb_address+i_mb_base < p_vpar->sequence.i_mb_size
 495            && !p_vpar->picture.b_error)
 496     {
 497         if( ((i_dummy = ShowBits( &p_vpar->bit_stream, 32 ))
 498                  < SLICE_START_CODE_MIN) ||
 499             (i_dummy > SLICE_START_CODE_MAX) )
 500         {
 501             intf_DbgMsg("vpar debug: premature end of picture");
 502             p_vpar->picture.b_error = TRUE;
 503             break;
 504         }
 505         DumpBits32( &p_vpar->bit_stream );
 506
 507         /* Decode slice data. */
 508         SliceHeader( p_vpar, &i_mb_address, i_mb_base, i_dummy & 255 );
 509     }
 510
 511     if( p_vpar->picture.b_error )
 512     {
 513         /* Trash picture. */
 514         for( i_mb = 0; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
 515         {
 516             vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 517         }
 518
 519         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
 520         vout_DestroyPicture( p_vpar->p_vout, P_picture );
 521
 522         /* Prepare context for the next picture. */
 523         P_picture = NULL:
 524     }
 525     else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 526     {
 527         /* Frame completely parsed. */
 528         for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size; i_mb++ )
 529         {
 530             vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 531         }
 532
 533         /* Prepare context for the next picture. */
 534         P_picture = NULL;
 535     }
 536 #undef P_picture
 537 }
 538
 539 /*****************************************************************************
 540  * ReferenceUpdate : Update the reference pointers when we have a new picture
 541  *****************************************************************************/
 542 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
 543                                         int i_coding_type,
 544                                         picture_t * p_newref )
 545 {
 546     if( i_coding_type != B_CODING_TYPE )
 547     {
 548         if( p_vpar->sequence.p_forward != NULL )
 549             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
 550         p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
 551         p_vpar->sequence.p_backward = p_newref;
 552         if( p_newref != NULL )
 553             vout_LinkPicture( p_vpar->p_vout, p_newref );
 554     }
 555 }
 556
 557 /*****************************************************************************
 558  * ReferenceReplace : Replace the last reference pointer when we destroy
 559  * a picture
 560  *****************************************************************************/
 561 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
 562                                          int i_coding_type,
 563                                          picture_t * p_newref )
 564 {
 565     if( i_coding_type != B_CODING_TYPE )
 566     {
 567         if( p_vpar->sequence.p_backward != NULL )
 568             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
 569         p_vpar->sequence.p_backward = p_newref;
 570         if( p_newref != NULL )
 571             vout_LinkPicture( p_vpar->p_vout, p_newref );
 572     }
 573 }
 574
 575 /*****************************************************************************
 576  * SliceHeaderXY : Parse the next slice structure
 577  *****************************************************************************
 578  * X = i_height > 2800 ?
 579  * Y = scalable_mode == SC_DP ?
 580  *****************************************************************************/
 581 static void SliceHeader00( vpar_thread_t * p_vpar,
 582                            int * pi_mb_address, int i_mb_base,
 583                            u32 i_vert_code )
 584 {
 585     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 586 }
 587
 588 static void SliceHeader01( vpar_thread_t * p_vpar,
 589                            int * pi_mb_address, int i_mb_base,
 590                            u32 i_vert_code )
 591 {
 592     DumpBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
 593     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 594 }
 595
 596 static void SliceHeader10( vpar_thread_t * p_vpar,
 597                            int * pi_mb_address, int i_mb_base,
 598                            u32 i_vert_code )
 599 {
 600     i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
 601     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 602 }
 603
 604 static void SliceHeader11( vpar_thread_t * p_vpar,
 605                            int * pi_mb_address, int i_mb_base,
 606                            u32 i_vert_code )
 607 {
 608     i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
 609     DumpBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
 610     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 611 }
 612
 613 /*****************************************************************************
 614  * SliceHeader : Parse the next slice structure
 615  *****************************************************************************/
 616 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
 617                                     int * pi_mb_address, int i_mb_base,
 618                                     u32 i_vert_code )
 619 {
 620     /* DC predictors initialization table */
 621     static int              pi_dc_dct_reinit[4] = {128,256,512,1024};
 622
 623     int                     i_mb_address_save = *pi_mb_address;
 624
 625     /* slice_vertical_position_extension and priority_breakpoint already done */
 626     LoadQuantizerScale( p_vpar );
 627
 628     if( GetBits( &p_vpar->bit_stream, 1 ) )
 629     {
 630         /* intra_slice, slice_id */
 631         DumpBits( &p_vpar->bit_stream, 8 );
 632         /* extra_information_slice */
 633         while( GetBits( &p_vpar->bit_stream, 1 ) )
 634         {
 635             DumpBits( &p_vpar->bit_stream, 8 );
 636         }
 637     }
 638
 639     *pi_mb_address = (i_vert_code - 1)*p_vpar->sequence.i_mb_width;
 640
 641     /* Reset DC coefficients predictors (ISO/IEC 13818-2 7.2.1). Why
 642      * does the reference decoder put 0 instead of the normative values ? */
 643     p_vpar->slice.pi_dct_pred[0] = p_vpar->slice.pi_dct_pred[1]
 644         = p_vpar->slice.pi_dct_pred[2]
 645         = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
 646
 647     /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
 648     bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
 649
 650     do
 651     {
 652         vpar_ParseMacroblock( p_vpar, pi_mb_address, i_mb_address_save,
 653                               i_mb_base );
 654         i_mb_address_save = *pi_mb_address;
 655     }
 656     while( !ShowBits( &p_vpar->bit_stream, 23 ) );
 657 }
 658
 659 /*****************************************************************************
 660  * ExtensionAndUserData : Parse the extension_and_user_data structure
 661  *****************************************************************************/
 662 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
 663 {
 664     while( !p_vpar->b_die )
 665     {
 666         NextStartCode( p_vpar );
 667         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
 668         {
 669         case EXTENSION_START_CODE:
 670             DumpBits32( &p_vpar->bit_stream );
 671             switch( GetBits( &p_vpar->bit_stream, 4 ) )
 672             {
 673             case SEQUENCE_DISPLAY_EXTENSION_ID:
 674                 SequenceDisplayExtension( p_vpar );
 675                 break;
 676             case QUANT_MATRIX_EXTENSION_ID:
 677                 QuantMatrixExtension( p_vpar );
 678                 break;
 679             case SEQUENCE_SCALABLE_EXTENSION_ID:
 680                 SequenceScalableExtension( p_vpar );
 681                 break;
 682             case PICTURE_DISPLAY_EXTENSION_ID:
 683                 PictureDisplayExtension( p_vpar );
 684                 break;
 685             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
 686                 PictureSpatialScalableExtension( p_vpar );
 687                 break;
 688             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
 689                 PictureTemporalScalableExtension( p_vpar );
 690                 break;
 691             case COPYRIGHT_EXTENSION_ID:
 692                 CopyrightExtension( p_vpar );
 693                 break;
 694             default:
 695             }
 696             break;
 697
 698         case USER_DATA_START_CODE:
 699             DumpBits32( &p_vpar->bit_stream );
 700             /* Wait for the next start code */
 701             break;
 702
 703         default:
 704             return;
 705         }
 706     }
 707 }
 708
 709
 710 /*****************************************************************************
 711  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
 712  *****************************************************************************/
 713
 714 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
 715 {
 716     /* We don't care sequence_display_extension. */
 717     /* video_format */
 718     DumpBits( &p_vpar->bit_stream, 3 );
 719     if( GetBits( &p_vpar->bit_stream, 1 ) )
 720     {
 721         /* Three bytes for color_desciption */
 722         DumpBits( &p_vpar->bit_stream, 24 );
 723     }
 724     /* display_horizontal and vertical_size and a marker_bit */
 725     DumpBits( &p_vpar->bit_stream, 29 );
 726 }
 727
 728
 729 /*****************************************************************************
 730  * QuantMatrixExtension : Load quantization matrices for luminance           *
 731  *                        and chrominance                                    *
 732  *****************************************************************************/
 733
 734 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
 735 {
 736     if( GetBits( &p_vpar->bit_stream, 1 ) )
 737     {
 738         /* Load intra_quantiser_matrix for luminance. */
 739         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 740     }
 741     else
 742     {
 743         /* Use the default matrix. */
 744         LinkMatrix( &p_vpar->sequence.intra_quant,
 745                     pi_default_intra_quant );
 746     }
 747     if( GetBits( &p_vpar->bit_stream, 1 ) )
 748     {
 749         /* Load non_intra_quantiser_matrix for luminance. */
 750         LoadMatrix( p_vpar, &p_vpar->sequence.non_intra_quant );
 751     }
 752     else
 753     {
 754         /* Use the default matrix. */
 755         LinkMatrix( &p_vpar->sequence.nonintra_quant,
 756                     pi_default_nonintra_quant );
 757     }
 758     if( GetBits( &p_vpar->bit_stream, 1 ) )
 759     {
 760         /* Load intra_quantiser_matrix for chrominance. */
 761         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
 762     }
 763     else
 764     {
 765         /* Link the chrominance intra matrix to the luminance one. */
 766         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 767                     &p_vpar->sequence.intra_quant );
 768     }
 769     if( GetBits( &p_vpar->bit_stream, 1 ) )
 770     {
 771         /* Load non_intra_quantiser_matrix for chrominance. */
 772         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 773     }
 774     else
 775     {
 776         /* Link the chrominance intra matrix to the luminance one. */
 777         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 778                     &p_vpar->sequence.intra_quant );
 779     }
 780     if( GetBits( &p_vpar->bit_stream, 1 ) )
 781     {
 782         /* Load non_intra_quantiser_matrix for chrominance. */
 783         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 784     }
 785     else
 786     {
 787         /* Link the chrominance nonintra matrix to the luminance one. */
 788         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 789                     &p_vpar->sequence.nonintra_quant );
 790     }
 791 }
 792
 793
 794 /*****************************************************************************
 795  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
 796  *                             structure to handle scalable coding           *
 797  *****************************************************************************/
 798
 799 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
 800 {
 801     /* We don't care about anything scalable except the scalable mode. */
 802     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
 803     /* The length of the structure depends on the value of the scalable_mode */
 804     {
 805         case 1:
 806             DumpBits32( &p_vpar->bit_stream );
 807             DumpBits( &p_vpar->bit_stream, 21 );
 808             break;
 809         case 2:
 810             DumpBits( &p_vpar->bit_stream, 12 );
 811             break;
 812         default:
 813             DumpBits( &p_vpar->bit_stream, 4 );
 814     }
 815
 816 }
 817 /*****************************************************************************
 818  * PictureDisplayExtension : Parse the picture_display_extension structure   *
 819  *****************************************************************************/
 820
 821 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
 822 {
 823     /* Number of frame center offset */
 824     int nb;
 825     /* I am not sure it works but it should
 826         (fewer tests than shown in §6.3.12) */
 827     nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
 828                                           p_vpar->picture.b_repeat_first_field +
 829                                           p_vpar->picture.b_top_field_first
 830                          : ( p_vpar->picture.b_frame_structure + 1 ) +
 831                            p_vpar->picture.b_repeat_first_field;
 832     DumpBits( &p_vpar->bit_stream, 34 * nb );
 833 }
 834
 835
 836 /*****************************************************************************
 837  * PictureSpatialScalableExtension                                           *
 838  *****************************************************************************/
 839
 840 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
 841 {
 842     /* That's scalable, so we trash it */
 843     DumpBits32( &p_vpar->bit_stream );
 844     DumpBits( &p_vpar->bit_stream, 14 );
 845 }
 846
 847
 848 /*****************************************************************************
 849  * PictureTemporalScalableExtension                                          *
 850  *****************************************************************************/
 851
 852 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
 853 {
 854     /* Scalable again, trashed again */
 855     DumpBits( &p_vpar->bit_stream, 23 );
 856 }
 857
 858
 859 /*****************************************************************************
 860  * CopyrightExtension : Keeps some legal informations                        *
 861  *****************************************************************************/
 862
 863 static void CopytrightExtension( vpar_thread_t * p_vpar )
 864 {
 865     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
 866     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
 867         /* A flag that says whether the copyright information is significant */
 868     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
 869         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
 870     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
 871         /* Reserved bits */
 872     DumpBits( &p_vpar->bit_stream, 8 );
 873         /* The copyright_number is split in three parts */
 874         /* first part */
 875     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
 876     DumpBits( &p_vpar->bit_stream, 1 );
 877         /* second part */
 878     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
 879     DumpBits( &p_vpar->bit_stream, 1 );
 880         /* third part and sum */
 881     p_vpar->sequence.i_copyright_nb = ( i_copyright_nb_1 << 44 ) +
 882                                       ( i_copyright_nb_2 << 22 ) +
 883                                       ( GetBits( &p_vpar->bit_stream, 22 ) );
 884 }
 885
 886
 887 /*****************************************************************************
 888  * LoadMatrix : Load a quantization matrix
 889  *****************************************************************************/
 890 static void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
 891 {
 892     int i_dummy;
 893
 894     if( !p_matrix->b_allocated )
 895     {
 896         /* Allocate a piece of memory to load the matrix. */
 897         p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) );
 898         p_matrix->b_allocated = TRUE;
 899     }
 900
 901     for( i_dummy = 0; i_dummy < 64; i_dummy++ )
 902     {
 903         p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
 904              = GetBits( p_vpar->bit_stream, 8 );
 905     }
 906
 907 #ifdef FOURIER_IDCT
 908     /* Discrete Fourier Transform requires the quantization matrices to
 909      * be normalized before using them. */
 910     vdec_NormQuantMatrix( p_matrix->pi_matrix );
 911 #endif
 912 }
 913
 914 /*****************************************************************************
 915  * LinkMatrix : Link a quantization matrix to another
 916  *****************************************************************************/
 917 static void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
 918 {
 919     int i_dummy;
 920
 921     if( p_matrix->b_allocated )
 922     {
 923         /* Deallocate the piece of memory. */
 924         free( p_matrix->pi_matrix );
 925         p_matrix->b_allocated = FALSE;
 926     }
 927
 928     p_matrix->pi_matrix = pi_array;
 929 }