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     if( p_matrix->b_allocated )
 242     {
 243         /* Deallocate the piece of memory. */
 244         free( p_matrix->pi_matrix );
 245         p_matrix->b_allocated = 0;
 246     }
 247
 248     p_matrix->pi_matrix = pi_array;
 249 }
 250
 251 /*
 252  * Exported functions.
 253  */
 254
 255 /*****************************************************************************
 256  * vpar_NextSequenceHeader : Find the next sequence header
 257  *****************************************************************************/
 258 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
 259 {
 260     while( !p_vpar->b_die )
 261     {
 262         NextStartCode( p_vpar );
 263         if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
 264             return 0;
 265         RemoveBits( &p_vpar->bit_stream, 8 );
 266     }
 267     return 1;
 268 }
 269
 270 /*****************************************************************************
 271  * vpar_ParseHeader : Parse the next header
 272  *****************************************************************************/
 273 int vpar_ParseHeader( vpar_thread_t * p_vpar )
 274 {
 275     while( !p_vpar->b_die )
 276     {
 277         NextStartCode( p_vpar );
 278         switch( GetBits32( &p_vpar->bit_stream ) )
 279         {
 280         case SEQUENCE_HEADER_CODE:
 281             SequenceHeader( p_vpar );
 282             return 0;
 283             break;
 284
 285         case GROUP_START_CODE:
 286             GroupHeader( p_vpar );
 287             return 0;
 288             break;
 289
 290         case PICTURE_START_CODE:
 291             PictureHeader( p_vpar );
 292             return 0;
 293             break;
 294
 295         case SEQUENCE_END_CODE:
 296             intf_DbgMsg("vpar debug: sequence end code received\n");
 297             return 1;
 298             break;
 299
 300         default:
 301         }
 302     }
 303
 304     return 0;
 305 }
 306
 307 /*
 308  * Following functions are local
 309  */
 310
 311 /*****************************************************************************
 312  * SequenceHeader : Parse the next sequence header
 313  *****************************************************************************/
 314 static void SequenceHeader( vpar_thread_t * p_vpar )
 315 {
 316 #define RESERVED    -1
 317     static float r_frame_rate_table[16] =
 318     {
 319         0.0,
 320         ((23.0*1000.0)/1001.0),
 321         24.0,
 322         25.0,
 323         ((30.0*1000.0)/1001.0),
 324         30.0,
 325         50.0,
 326         ((60.0*1000.0)/1001.0),
 327         60.0,
 328         RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
 329     };
 330 #undef RESERVED
 331
 332     int i_height_save, i_width_save;
 333
 334     i_height_save = p_vpar->sequence.i_height;
 335     i_width_save = p_vpar->sequence.i_width;
 336
 337     p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
 338     p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
 339     p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
 340     p_vpar->sequence.r_frame_rate =
 341             r_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
 342
 343     /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
 344      * constrained_parameters_flag */
 345     RemoveBits( &p_vpar->bit_stream, 30 );
 346
 347     /*
 348      * Quantization matrices
 349      */
 350     if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
 351     {
 352         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 353     }
 354     else
 355     {
 356         /* Use default matrix. */
 357         LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
 358     }
 359
 360     if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
 361     {
 362         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 363     }
 364     else
 365     {
 366         /* Use default matrix. */
 367         LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
 368     }
 369
 370     /* Unless later overwritten by a matrix extension, we have the same
 371      * matrices for luminance and chrominance. */
 372     LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 373                 p_vpar->sequence.intra_quant.pi_matrix );
 374     LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 375                 p_vpar->sequence.nonintra_quant.pi_matrix );
 376
 377     /*
 378      * Sequence Extension
 379      */
 380     NextStartCode( p_vpar );
 381     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
 382     {
 383         int                         i_dummy;
 384         static f_chroma_pattern_t   ppf_chroma_pattern[4] =
 385                             {NULL, vpar_CodedPattern420,
 386                              vpar_CodedPattern422, vpar_CodedPattern444};
 387
 388         /* Turn the MPEG2 flag on */
 389         p_vpar->sequence.b_mpeg2 = 1;
 390
 391         /* Parse sequence_extension */
 392         RemoveBits32( &p_vpar->bit_stream );
 393         /* extension_start_code_identifier, profile_and_level_indication */
 394         RemoveBits( &p_vpar->bit_stream, 12 );
 395         p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
 396         p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
 397         p_vpar->sequence.pf_decode_pattern = ppf_chroma_pattern
 398                                     [p_vpar->sequence.i_chroma_format];
 399         p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
 400         p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
 401         /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
 402         RemoveBits( &p_vpar->bit_stream, 22 );
 403         /* frame_rate_extension_n */
 404         i_dummy = GetBits( &p_vpar->bit_stream, 2 );
 405         /* frame_rate_extension_d */
 406         p_vpar->sequence.r_frame_rate *= (i_dummy + 1)
 407                                   / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
 408
 409         p_vpar->sequence.pf_decode_mv = vpar_MPEG2MotionVector;
 410     }
 411     else
 412     {
 413         /* It's an MPEG-1 stream. Put adequate parameters. */
 414
 415         p_vpar->sequence.b_mpeg2 = 0;
 416         p_vpar->sequence.b_progressive = 1;
 417         p_vpar->sequence.i_chroma_format = CHROMA_420;
 418         p_vpar->sequence.pf_decode_pattern = vpar_CodedPattern420;
 419
 420         p_vpar->sequence.pf_decode_mv = vpar_MPEG1MotionVector;
 421     }
 422
 423     /* Update sizes */
 424     p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
 425     p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
 426                                    (p_vpar->sequence.i_height + 15) / 16 :
 427                                    2 * ((p_vpar->sequence.i_height + 31) / 32);
 428     p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
 429                                         * p_vpar->sequence.i_mb_height;
 430     p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
 431     p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
 432     p_vpar->sequence.i_size = p_vpar->sequence.i_width
 433                                         * p_vpar->sequence.i_height;
 434
 435     /* Update chromatic information */
 436     switch( p_vpar->sequence.i_chroma_format )
 437     {
 438     case CHROMA_420:
 439         p_vpar->sequence.i_chroma_nb_blocks = 2;
 440         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
 441         p_vpar->sequence.i_chroma_mb_width = 8;
 442         p_vpar->sequence.i_chroma_mb_height = 8;
 443         break;
 444
 445     case CHROMA_422:
 446         p_vpar->sequence.i_chroma_nb_blocks = 4;
 447         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
 448         p_vpar->sequence.i_chroma_mb_width = 8;
 449         p_vpar->sequence.i_chroma_mb_height = 16;
 450         break;
 451
 452     case CHROMA_444:
 453         p_vpar->sequence.i_chroma_nb_blocks = 8;
 454         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
 455         p_vpar->sequence.i_chroma_mb_width = 16;
 456         p_vpar->sequence.i_chroma_mb_height = 16;
 457     }
 458
 459     /* Slice Header functions */
 460     if( p_vpar->sequence.i_height <= 2800 )
 461     {
 462         if( p_vpar->sequence.i_scalable_mode != SC_DP )
 463         {
 464             p_vpar->sequence.pf_slice_header = SliceHeader00;
 465         }
 466         else
 467         {
 468             p_vpar->sequence.pf_slice_header = SliceHeader01;
 469         }
 470     }
 471     else
 472     {
 473         if( p_vpar->sequence.i_scalable_mode != SC_DP )
 474         {
 475             p_vpar->sequence.pf_slice_header = SliceHeader10;
 476         }
 477         else
 478         {
 479             p_vpar->sequence.pf_slice_header = SliceHeader11;
 480         }
 481     }
 482
 483     if(    p_vpar->sequence.i_width != i_width_save
 484         || p_vpar->sequence.i_height != i_height_save )
 485     {
 486          /* What do we do in case of a size change ??? */
 487     }
 488
 489     /* Extension and User data */
 490     ExtensionAndUserData( p_vpar );
 491 }
 492
 493 /*****************************************************************************
 494  * GroupHeader : Parse the next group of pictures header
 495  *****************************************************************************/
 496 static void GroupHeader( vpar_thread_t * p_vpar )
 497 {
 498     /* Nothing to do, we don't care. */
 499     RemoveBits( &p_vpar->bit_stream, 27 );
 500     ExtensionAndUserData( p_vpar );
 501 }
 502
 503 /*****************************************************************************
 504  * PictureHeader : Parse the next picture header
 505  *****************************************************************************/
 506 static void PictureHeader( vpar_thread_t * p_vpar )
 507 {
 508     static f_macroblock_type_t ppf_macroblock_type[5] = {NULL,
 509                                                   vpar_IMBType, vpar_PMBType,
 510                                                   vpar_BMBType, vpar_DMBType};
 511
 512     int                 i_structure;
 513     int                 i_mb_address, i_mb_base, i_mb;
 514     boolean_t           b_parsable;
 515     u32                 i_dummy;
 516
 517     RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
 518     p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
 519     p_vpar->picture.pf_macroblock_type = ppf_macroblock_type
 520                                          [p_vpar->picture.i_coding_type];
 521     RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
 522
 523     if( p_vpar->picture.i_coding_type == P_CODING_TYPE || p_vpar->picture.i_coding_type == B_CODING_TYPE )
 524     {
 525         p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
 526         p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
 527     }
 528     if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
 529     {
 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
 534     /* extra_information_picture */
 535     while( GetBits( &p_vpar->bit_stream, 1 ) )
 536     {
 537         RemoveBits( &p_vpar->bit_stream, 8 );
 538     }
 539
 540     /*
 541      * Picture Coding Extension
 542      */
 543     NextStartCode( p_vpar );
 544     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
 545     {
 546         /* Parse picture_coding_extension */
 547         RemoveBits32( &p_vpar->bit_stream );
 548         /* extension_start_code_identifier */
 549         RemoveBits( &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         RemoveBits( &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             RemoveBits( &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.\n");
 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_backward == NULL)) ||
 628                         /* p_backward will become p_forward later */
 629                       ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
 630                        (p_vpar->sequence.p_forward == NULL ||
 631                         p_vpar->sequence.p_backward == NULL));
 632
 633         if( b_parsable )
 634         {
 635             /* Does synchro say we have enough time to decode it ? */
 636             b_parsable = vpar_SynchroChoose( p_vpar,
 637                                p_vpar->picture.i_coding_type, i_structure );
 638         }
 639     }
 640
 641     if( !b_parsable )
 642     {
 643         /* Update the reference pointers. */
 644         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
 645
 646         /* Warn Synchro we have trashed a picture. */
 647         vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 648
 649         /* Update context. */
 650         if( i_structure != FRAME_STRUCTURE )
 651             p_vpar->picture.i_current_structure = i_structure;
 652         p_vpar->picture.p_picture = NULL;
 653
 654         return;
 655     }
 656
 657     /* OK, now we are sure we will decode the picture. */
 658 #define P_picture p_vpar->picture.p_picture
 659     p_vpar->picture.b_error = 0;
 660
 661     if( !p_vpar->picture.i_current_structure )
 662     {
 663         /* This is a new frame. Get a structure from the video_output. */
 664         while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
 665                                         99+p_vpar->sequence.i_chroma_format, /*???*/
 666                                         p_vpar->sequence.i_width,
 667                                         p_vpar->sequence.i_height ) )
 668              == NULL )
 669         {
 670             intf_ErrMsg("vpar debug: allocation error in vout_CreatePicture\n");
 671             if( p_vpar->b_die )
 672             {
 673                 return;
 674             }
 675             mwait( VPAR_IDLE_SLEEP );
 676         }
 677
 678         /* Initialize values. */
 679         P_picture->date = vpar_SynchroDecode( p_vpar,
 680                                               p_vpar->picture.i_coding_type,
 681                                               i_structure );
 682         P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
 683         P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
 684         p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
 685                     << ( 1 - p_vpar->picture.b_frame_structure ) );
 686         p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
 687                     << ( 1 - p_vpar->picture.b_frame_structure ));
 688
 689         P_picture->i_deccount = p_vpar->sequence.i_mb_size;
 690         memset( p_vpar->picture.pp_mb, 0, MAX_MB );
 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\n");
 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 = 1; 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         vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
 745
 746         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
 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 (%d)\n", p_vpar->picture.i_coding_type);
 756         /* Frame completely parsed. */
 757         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
 758         {
 759             vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 760         }
 761
 762         /* Link referenced pictures for the decoder
 763          * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
 764 #if 0
 765         if( p_vpar->sequence.p_forward != NULL )
 766         {
 767             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
 768         }
 769         if( p_vpar->sequence.p_backward != NULL )
 770         {
 771             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
 772         }
 773 #endif
 774         /* Send signal to the video_decoder. */
 775         vlc_mutex_lock( &p_vpar->vfifo.lock );
 776         vlc_cond_signal( &p_vpar->vfifo.wait );
 777         vlc_mutex_unlock( &p_vpar->vfifo.lock );
 778
 779         /* Prepare context for the next picture. */
 780         P_picture = NULL;
 781         p_vpar->picture.i_current_structure = 0;
 782     }
 783 #undef P_picture
 784 }
 785
 786 /*****************************************************************************
 787  * SliceHeader : Parse the next slice structure
 788  *****************************************************************************/
 789 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
 790                                     int * pi_mb_address, int i_mb_base,
 791                                     u32 i_vert_code )
 792 {
 793     /* DC predictors initialization table */
 794     static int              pi_dc_dct_reinit[4] = {128,256,512,1024};
 795
 796     int                     i_mb_address_save = *pi_mb_address;
 797
 798     /* slice_vertical_position_extension and priority_breakpoint already done */
 799     LoadQuantizerScale( p_vpar );
 800
 801     if( GetBits( &p_vpar->bit_stream, 1 ) )
 802     {
 803         /* intra_slice, slice_id */
 804         RemoveBits( &p_vpar->bit_stream, 8 );
 805         /* extra_information_slice */
 806         while( GetBits( &p_vpar->bit_stream, 1 ) )
 807         {
 808             RemoveBits( &p_vpar->bit_stream, 8 );
 809         }
 810     }
 811     *pi_mb_address = (i_vert_code - 1)*p_vpar->sequence.i_mb_width;
 812
 813     /* Reset DC coefficients predictors (ISO/IEC 13818-2 7.2.1). Why
 814      * does the reference decoder put 0 instead of the normative values ? */
 815     p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
 816         = p_vpar->slice.pi_dc_dct_pred[2]
 817         = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
 818
 819     /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
 820     memset( p_vpar->slice.pppi_pmv, 0, 8*sizeof(int) );
 821
 822     do
 823     {
 824         vpar_ParseMacroblock( p_vpar, pi_mb_address, i_mb_address_save,
 825                               i_mb_base );
 826         i_mb_address_save = *pi_mb_address;
 827     }
 828     while( ShowBits( &p_vpar->bit_stream, 23 ) && !p_vpar->b_die );
 829     NextStartCode( p_vpar );
 830 }
 831
 832 /*****************************************************************************
 833  * SliceHeaderXY : Parse the next slice structure
 834  *****************************************************************************
 835  * X = i_height > 2800 ?
 836  * Y = scalable_mode == SC_DP ?
 837  *****************************************************************************/
 838 static void SliceHeader00( vpar_thread_t * p_vpar,
 839                            int * pi_mb_address, int i_mb_base,
 840                            u32 i_vert_code )
 841 {
 842     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 843 }
 844
 845 static void SliceHeader01( vpar_thread_t * p_vpar,
 846                            int * pi_mb_address, int i_mb_base,
 847                            u32 i_vert_code )
 848 {
 849     RemoveBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
 850     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 851 }
 852
 853 static void SliceHeader10( vpar_thread_t * p_vpar,
 854                            int * pi_mb_address, int i_mb_base,
 855                            u32 i_vert_code )
 856 {
 857     i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
 858     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 859 }
 860
 861 static void SliceHeader11( vpar_thread_t * p_vpar,
 862                            int * pi_mb_address, int i_mb_base,
 863                            u32 i_vert_code )
 864 {
 865     i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
 866     RemoveBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
 867     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 868 }
 869
 870 /*****************************************************************************
 871  * ExtensionAndUserData : Parse the extension_and_user_data structure
 872  *****************************************************************************/
 873 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
 874 {
 875     while( !p_vpar->b_die )
 876     {
 877         NextStartCode( p_vpar );
 878         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
 879         {
 880         case EXTENSION_START_CODE:
 881             RemoveBits32( &p_vpar->bit_stream );
 882             switch( GetBits( &p_vpar->bit_stream, 4 ) )
 883             {
 884             case SEQUENCE_DISPLAY_EXTENSION_ID:
 885                 SequenceDisplayExtension( p_vpar );
 886                 break;
 887             case QUANT_MATRIX_EXTENSION_ID:
 888                 QuantMatrixExtension( p_vpar );
 889                 break;
 890             case SEQUENCE_SCALABLE_EXTENSION_ID:
 891                 SequenceScalableExtension( p_vpar );
 892                 break;
 893             case PICTURE_DISPLAY_EXTENSION_ID:
 894                 PictureDisplayExtension( p_vpar );
 895                 break;
 896             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
 897                 PictureSpatialScalableExtension( p_vpar );
 898                 break;
 899             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
 900                 PictureTemporalScalableExtension( p_vpar );
 901                 break;
 902             case COPYRIGHT_EXTENSION_ID:
 903                 CopyrightExtension( p_vpar );
 904                 break;
 905             default:
 906             }
 907             break;
 908
 909         case USER_DATA_START_CODE:
 910             RemoveBits32( &p_vpar->bit_stream );
 911             /* Wait for the next start code */
 912             break;
 913
 914         default:
 915             return;
 916         }
 917     }
 918 }
 919
 920
 921 /*****************************************************************************
 922  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
 923  *****************************************************************************/
 924
 925 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
 926 {
 927     /* We don't care sequence_display_extension. */
 928     /* video_format */
 929     RemoveBits( &p_vpar->bit_stream, 3 );
 930     if( GetBits( &p_vpar->bit_stream, 1 ) )
 931     {
 932         /* Two bytes for color_desciption */
 933         RemoveBits( &p_vpar->bit_stream, 16 );
 934         p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
 935     }
 936     /* display_horizontal and vertical_size and a marker_bit */
 937     RemoveBits( &p_vpar->bit_stream, 29 );
 938 }
 939
 940
 941 /*****************************************************************************
 942  * QuantMatrixExtension : Load quantization matrices for luminance           *
 943  *                        and chrominance                                    *
 944  *****************************************************************************/
 945
 946 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
 947 {
 948     if( GetBits( &p_vpar->bit_stream, 1 ) )
 949     {
 950         /* Load intra_quantiser_matrix for luminance. */
 951         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 952     }
 953     else
 954     {
 955         /* Use the default matrix. */
 956         LinkMatrix( &p_vpar->sequence.intra_quant,
 957                     pi_default_intra_quant );
 958     }
 959     if( GetBits( &p_vpar->bit_stream, 1 ) )
 960     {
 961         /* Load non_intra_quantiser_matrix for luminance. */
 962         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 963     }
 964     else
 965     {
 966         /* Use the default matrix. */
 967         LinkMatrix( &p_vpar->sequence.nonintra_quant,
 968                     pi_default_nonintra_quant );
 969     }
 970     if( GetBits( &p_vpar->bit_stream, 1 ) )
 971     {
 972         /* Load intra_quantiser_matrix for chrominance. */
 973         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
 974     }
 975     else
 976     {
 977         /* Link the chrominance intra matrix to the luminance one. */
 978         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 979                     p_vpar->sequence.intra_quant.pi_matrix );
 980     }
 981     if( GetBits( &p_vpar->bit_stream, 1 ) )
 982     {
 983         /* Load non_intra_quantiser_matrix for chrominance. */
 984         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 985     }
 986     else
 987     {
 988         /* Link the chrominance intra matrix to the luminance one. */
 989         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 990                     p_vpar->sequence.intra_quant.pi_matrix );
 991     }
 992     if( GetBits( &p_vpar->bit_stream, 1 ) )
 993     {
 994         /* Load non_intra_quantiser_matrix for chrominance. */
 995         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 996     }
 997     else
 998     {
 999         /* Link the chrominance nonintra matrix to the luminance one. */
1000         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
1001                     p_vpar->sequence.nonintra_quant.pi_matrix );
1002     }
1003 }
1004
1005
1006 /*****************************************************************************
1007  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
1008  *                             structure to handle scalable coding           *
1009  *****************************************************************************/
1010
1011 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1012 {
1013     /* We don't care about anything scalable except the scalable mode. */
1014     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1015     /* The length of the structure depends on the value of the scalable_mode */
1016     {
1017         case 1:
1018             RemoveBits32( &p_vpar->bit_stream );
1019             RemoveBits( &p_vpar->bit_stream, 21 );
1020             break;
1021         case 2:
1022             RemoveBits( &p_vpar->bit_stream, 12 );
1023             break;
1024         default:
1025             RemoveBits( &p_vpar->bit_stream, 4 );
1026     }
1027
1028 }
1029 /*****************************************************************************
1030  * PictureDisplayExtension : Parse the picture_display_extension structure   *
1031  *****************************************************************************/
1032
1033 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1034 {
1035     /* Number of frame center offset */
1036     int nb;
1037     /* I am not sure it works but it should
1038         (fewer tests than shown in §6.3.12) */
1039     nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1040                                           p_vpar->picture.b_repeat_first_field +
1041                                           p_vpar->picture.b_top_field_first
1042                          : ( p_vpar->picture.b_frame_structure + 1 ) +
1043                            p_vpar->picture.b_repeat_first_field;
1044     RemoveBits( &p_vpar->bit_stream, 34 * nb );
1045 }
1046
1047
1048 /*****************************************************************************
1049  * PictureSpatialScalableExtension                                           *
1050  *****************************************************************************/
1051
1052 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1053 {
1054     /* That's scalable, so we trash it */
1055     RemoveBits32( &p_vpar->bit_stream );
1056     RemoveBits( &p_vpar->bit_stream, 16 );
1057 }
1058
1059
1060 /*****************************************************************************
1061  * PictureTemporalScalableExtension                                          *
1062  *****************************************************************************/
1063
1064 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1065 {
1066     /* Scalable again, trashed again */
1067     RemoveBits( &p_vpar->bit_stream, 23 );
1068 }
1069
1070
1071 /*****************************************************************************
1072  * CopyrightExtension : Keeps some legal informations                        *
1073  *****************************************************************************/
1074
1075 static void CopyrightExtension( vpar_thread_t * p_vpar )
1076 {
1077     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1078     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1079         /* A flag that says whether the copyright information is significant */
1080     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1081         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1082     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1083         /* Reserved bits */
1084     RemoveBits( &p_vpar->bit_stream, 8 );
1085         /* The copyright_number is split in three parts */
1086         /* first part */
1087     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1088     RemoveBits( &p_vpar->bit_stream, 1 );
1089         /* second part */
1090     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1091     RemoveBits( &p_vpar->bit_stream, 1 );
1092         /* third part and sum */
1093     p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) +
1094                                       ( (u64)i_copyright_nb_2 << 22 ) +
1095                                       ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );
1096 }