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