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