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         DumpBits( &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         DumpBits( &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 double d_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_height = GetBits( &p_vpar->bit_stream, 12 );
 344     p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
 345     p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
 346     p_vpar->sequence.d_frame_rate =
 347             d_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     DumpBits( &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         DumpBits32( &p_vpar->bit_stream );
 399         /* extension_start_code_identifier, profile_and_level_indication */
 400         DumpBits( &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         DumpBits( &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.d_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 >> 2;
 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     DumpBits( &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     DumpBits( &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
 529     DumpBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
 530
 531     p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
 532     p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
 533     p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
 534     p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
 535
 536     /* extra_information_picture */
 537     while( GetBits( &p_vpar->bit_stream, 1 ) )
 538     {
 539         DumpBits( &p_vpar->bit_stream, 8 );
 540     }
 541
 542     /*
 543      * Picture Coding Extension
 544      */
 545
 546     NextStartCode( p_vpar );
 547     if( ShowBits( &p_vpar->bit_stream, 16 ) == EXTENSION_START_CODE )
 548     {
 549         /* Parse picture_coding_extension */
 550         DumpBits32( &p_vpar->bit_stream );
 551         /* extension_start_code_identifier */
 552         DumpBits( &p_vpar->bit_stream, 4 );
 553
 554         p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
 555         p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
 556         p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
 557         p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
 558         p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
 559         i_structure = GetBits( &p_vpar->bit_stream, 2 );
 560         p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
 561         p_vpar->picture.b_frame_pred_frame_dct
 562              = GetBits( &p_vpar->bit_stream, 1 );
 563         p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
 564         p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
 565         p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
 566         p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
 567         p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
 568         /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
 569          * the length of the picture_display_extension structure.
 570          * chroma_420_type (obsolete) */
 571         DumpBits( &p_vpar->bit_stream, 1 );
 572         p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
 573
 574         /* composite_display_flag */
 575         if( GetBits( &p_vpar->bit_stream, 1 ) )
 576         {
 577             /* v_axis, field_sequence, sub_carrier, burst_amplitude,
 578              * sub_carrier_phase */
 579             DumpBits( &p_vpar->bit_stream, 20 );
 580         }
 581     }
 582     else
 583     {
 584         /* MPEG-1 compatibility flags */
 585         p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
 586         i_structure = FRAME_STRUCTURE;
 587         p_vpar->picture.b_frame_pred_frame_dct = 1;
 588         p_vpar->picture.b_concealment_mv = 0;
 589         p_vpar->picture.b_q_scale_type = 0;
 590         p_vpar->picture.b_intra_vlc_format = 0;
 591         p_vpar->picture.b_alternate_scan = 0; /* zigzag */
 592         p_vpar->picture.b_repeat_first_field = 0;
 593         p_vpar->picture.b_progressive_frame = 1;
 594     }
 595
 596     if( p_vpar->picture.i_current_structure &&
 597         (i_structure == FRAME_STRUCTURE ||
 598          i_structure == p_vpar->picture.i_current_structure) )
 599     {
 600         /* We don't have the second field of the buffered frame. */
 601         if( p_vpar->picture.p_picture != NULL )
 602         {
 603             ReferenceReplace( p_vpar,
 604                       p_vpar->picture.i_coding_type,
 605                       NULL );
 606
 607             for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size >> 1; i_mb++ )
 608             {
 609                 vpar_DestroyMacroblock( &p_vpar->vfifo,
 610                                         p_vpar->picture.pp_mb[i_mb] );
 611             }
 612             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
 613         }
 614
 615         p_vpar->picture.i_current_structure = 0;
 616
 617         intf_DbgMsg("vpar debug: odd number of field picture.\n");
 618     }
 619
 620     if( p_vpar->picture.i_current_structure )
 621     {
 622         /* Second field of a frame. We will decode it if, and only if we
 623          * have decoded the first frame. */
 624         b_parsable = (p_vpar->picture.p_picture != NULL);
 625     }
 626     else
 627     {
 628         /* Do we have the reference pictures ? */
 629         b_parsable = !((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
 630                        (p_vpar->sequence.p_forward == NULL)) ||
 631                       ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
 632                        (p_vpar->sequence.p_forward == NULL ||
 633                         p_vpar->sequence.p_backward == NULL));
 634
 635         if( b_parsable )
 636         {
 637             /* Does synchro say we have enough time to decode it ? */
 638             b_parsable = vpar_SynchroChoose( p_vpar,
 639                                p_vpar->picture.i_coding_type, i_structure );
 640         }
 641     }
 642
 643     if( !b_parsable )
 644     {
 645         /* Update the reference pointers. */
 646         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
 647
 648         /* Warn Synchro we have trashed a picture. */
 649         vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 650
 651         /* Update context. */
 652         if( i_structure != FRAME_STRUCTURE )
 653             p_vpar->picture.i_current_structure = i_structure;
 654         p_vpar->picture.p_picture = NULL;
 655
 656         return;
 657     }
 658     fprintf(stderr, "begin picture\n");
 659
 660     /* OK, now we are sure we will decode the picture. */
 661 #define P_picture p_vpar->picture.p_picture
 662     p_vpar->picture.b_error = 0;
 663
 664     if( !p_vpar->picture.i_current_structure )
 665     {
 666         /* This is a new frame. Get a structure from the video_output. */
 667         P_picture = vout_CreatePicture( p_vpar->p_vout,
 668                                         99+p_vpar->sequence.i_chroma_format, /*???*/
 669                                         p_vpar->sequence.i_width,
 670                                         p_vpar->sequence.i_height,
 671                                         p_vpar->sequence.i_width*sizeof(yuv_data_t) );
 672
 673         /* Initialize values. */
 674         P_picture->date = vpar_SynchroDecode( p_vpar,
 675                                               p_vpar->picture.i_coding_type,
 676                                               i_structure );
 677         p_vpar->picture.i_l_stride = - 8 + ( p_vpar->sequence.i_width
 678                     << ( 1 - p_vpar->picture.b_frame_structure ) );
 679         p_vpar->picture.i_c_stride = -8 + ( p_vpar->sequence.i_width
 680                     << (( 1 - p_vpar->picture.b_frame_structure ) +
 681                         ( 3 - p_vpar->sequence.i_chroma_format )) );
 682
 683         /* Update the reference pointers. */
 684         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
 685     }
 686     p_vpar->picture.i_current_structure |= i_structure;
 687     p_vpar->picture.i_structure = i_structure;
 688     p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
 689
 690     /* Initialize picture data for decoding. */
 691     if( i_structure == BOTTOM_FIELD )
 692     {
 693         i_mb_base = p_vpar->sequence.i_mb_size >> 1;
 694         p_vpar->mb.i_l_y = 16;
 695         p_vpar->mb.i_c_y = p_vpar->sequence.i_chroma_mb_height;
 696     }
 697     else
 698     {
 699         i_mb_base = 0;
 700         p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
 701     }
 702     i_mb_address = 0;
 703     p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
 704
 705     /* Extension and User data. */
 706     ExtensionAndUserData( p_vpar );
 707
 708     /* Picture data (ISO/IEC 13818-2 6.2.3.7). */
 709     NextStartCode( p_vpar );
 710     while( i_mb_address+i_mb_base < p_vpar->sequence.i_mb_size
 711            && !p_vpar->picture.b_error)
 712     {
 713         if( ((i_dummy = ShowBits( &p_vpar->bit_stream, 32 ))
 714                  < SLICE_START_CODE_MIN) ||
 715             (i_dummy > SLICE_START_CODE_MAX) )
 716         {
 717             intf_DbgMsg("vpar debug: premature end of picture");
 718             p_vpar->picture.b_error = 1;
 719             break;
 720         }
 721         DumpBits32( &p_vpar->bit_stream );
 722
 723         /* Decode slice data. */
 724         p_vpar->sequence.pf_slice_header( p_vpar, &i_mb_address, i_mb_base, i_dummy & 255 );
 725     }
 726
 727     /* Link referenced pictures for the decoder
 728      * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
 729     if( p_vpar->sequence.p_forward != NULL )
 730     {
 731             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
 732     }
 733     if( p_vpar->sequence.p_backward != NULL )
 734     {
 735         vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
 736     }
 737
 738     if( p_vpar->picture.b_error )
 739     {
 740         /* Trash picture. */
 741 fprintf(stderr, "Image trashee\n");
 742         for( i_mb = 0; p_vpar->picture.pp_mb[i_mb]; i_mb++ )
 743         {
 744             vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 745         }
 746
 747         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
 748         vout_DestroyPicture( p_vpar->p_vout, P_picture );
 749
 750         /* Unlink referenced pictures */
 751         if(  p_vpar->sequence.p_forward != NULL  )
 752         {
 753                 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
 754         }
 755         if( p_vpar->sequence.p_backward != NULL )
 756         {
 757             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
 758         }
 759
 760         /* Prepare context for the next picture. */
 761         P_picture = NULL;
 762         if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 763             p_vpar->picture.i_current_structure = 0;
 764     }
 765     else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 766     {
 767 fprintf(stderr, "Image decodee\n");
 768         /* Frame completely parsed. */
 769         P_picture->i_deccount = p_vpar->sequence.i_mb_size;
 770         for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size; i_mb++ )
 771         {
 772             vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 773         }
 774
 775         /* Prepare context for the next picture. */
 776         P_picture = NULL;
 777     p_vpar->picture.i_current_structure = 0;
 778     }
 779 #undef P_picture
 780 }
 781
 782 /*****************************************************************************
 783  * SliceHeader : Parse the next slice structure
 784  *****************************************************************************/
 785 static __inline__ void SliceHeader( vpar_thread_t * p_vpar,
 786                                     int * pi_mb_address, int i_mb_base,
 787                                     u32 i_vert_code )
 788 {
 789     /* DC predictors initialization table */
 790     static int              pi_dc_dct_reinit[4] = {128,256,512,1024};
 791
 792     int                     i_mb_address_save = *pi_mb_address;
 793
 794     /* slice_vertical_position_extension and priority_breakpoint already done */
 795     LoadQuantizerScale( p_vpar );
 796
 797     if( GetBits( &p_vpar->bit_stream, 1 ) )
 798     {
 799         /* intra_slice, slice_id */
 800         DumpBits( &p_vpar->bit_stream, 8 );
 801         /* extra_information_slice */
 802         while( GetBits( &p_vpar->bit_stream, 1 ) )
 803         {
 804             DumpBits( &p_vpar->bit_stream, 8 );
 805         }
 806     }
 807
 808     *pi_mb_address = (i_vert_code - 1)*p_vpar->sequence.i_mb_width;
 809
 810     /* Reset DC coefficients predictors (ISO/IEC 13818-2 7.2.1). Why
 811      * does the reference decoder put 0 instead of the normative values ? */
 812     p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
 813         = p_vpar->slice.pi_dc_dct_pred[2]
 814         = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
 815
 816     /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
 817     memset( p_vpar->slice.pppi_pmv, 0, 8*sizeof(int) );
 818
 819     do
 820     {
 821         vpar_ParseMacroblock( p_vpar, pi_mb_address, i_mb_address_save,
 822                               i_mb_base );
 823         i_mb_address_save = *pi_mb_address;
 824     }
 825     while( ShowBits( &p_vpar->bit_stream, 23 ) );
 826     NextStartCode( p_vpar );
 827 }
 828
 829 /*****************************************************************************
 830  * SliceHeaderXY : Parse the next slice structure
 831  *****************************************************************************
 832  * X = i_height > 2800 ?
 833  * Y = scalable_mode == SC_DP ?
 834  *****************************************************************************/
 835 static void SliceHeader00( vpar_thread_t * p_vpar,
 836                            int * pi_mb_address, int i_mb_base,
 837                            u32 i_vert_code )
 838 {
 839     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 840 }
 841
 842 static void SliceHeader01( vpar_thread_t * p_vpar,
 843                            int * pi_mb_address, int i_mb_base,
 844                            u32 i_vert_code )
 845 {
 846     DumpBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
 847     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 848 }
 849
 850 static void SliceHeader10( vpar_thread_t * p_vpar,
 851                            int * pi_mb_address, int i_mb_base,
 852                            u32 i_vert_code )
 853 {
 854     i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
 855     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 856 }
 857
 858 static void SliceHeader11( vpar_thread_t * p_vpar,
 859                            int * pi_mb_address, int i_mb_base,
 860                            u32 i_vert_code )
 861 {
 862     i_vert_code += GetBits( &p_vpar->bit_stream, 3 ) << 7;
 863     DumpBits( &p_vpar->bit_stream, 7 ); /* priority_breakpoint */
 864     SliceHeader( p_vpar, pi_mb_address, i_mb_base, i_vert_code );
 865 }
 866
 867 /*****************************************************************************
 868  * ExtensionAndUserData : Parse the extension_and_user_data structure
 869  *****************************************************************************/
 870 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
 871 {
 872     while( !p_vpar->b_die )
 873     {
 874         NextStartCode( p_vpar );
 875         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
 876         {
 877         case EXTENSION_START_CODE:
 878             DumpBits32( &p_vpar->bit_stream );
 879             switch( GetBits( &p_vpar->bit_stream, 4 ) )
 880             {
 881             case SEQUENCE_DISPLAY_EXTENSION_ID:
 882                 SequenceDisplayExtension( p_vpar );
 883                 break;
 884             case QUANT_MATRIX_EXTENSION_ID:
 885                 QuantMatrixExtension( p_vpar );
 886                 break;
 887             case SEQUENCE_SCALABLE_EXTENSION_ID:
 888                 SequenceScalableExtension( p_vpar );
 889                 break;
 890             case PICTURE_DISPLAY_EXTENSION_ID:
 891                 PictureDisplayExtension( p_vpar );
 892                 break;
 893             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
 894                 PictureSpatialScalableExtension( p_vpar );
 895                 break;
 896             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
 897                 PictureTemporalScalableExtension( p_vpar );
 898                 break;
 899             case COPYRIGHT_EXTENSION_ID:
 900                 CopyrightExtension( p_vpar );
 901                 break;
 902             default:
 903             }
 904             break;
 905
 906         case USER_DATA_START_CODE:
 907             DumpBits32( &p_vpar->bit_stream );
 908             /* Wait for the next start code */
 909             break;
 910
 911         default:
 912             return;
 913         }
 914     }
 915 }
 916
 917
 918 /*****************************************************************************
 919  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
 920  *****************************************************************************/
 921
 922 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
 923 {
 924     /* We don't care sequence_display_extension. */
 925     /* video_format */
 926     DumpBits( &p_vpar->bit_stream, 3 );
 927     if( GetBits( &p_vpar->bit_stream, 1 ) )
 928     {
 929         /* Three bytes for color_desciption */
 930         DumpBits( &p_vpar->bit_stream, 24 );
 931     }
 932     /* display_horizontal and vertical_size and a marker_bit */
 933     DumpBits( &p_vpar->bit_stream, 29 );
 934 }
 935
 936
 937 /*****************************************************************************
 938  * QuantMatrixExtension : Load quantization matrices for luminance           *
 939  *                        and chrominance                                    *
 940  *****************************************************************************/
 941
 942 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
 943 {
 944     if( GetBits( &p_vpar->bit_stream, 1 ) )
 945     {
 946         /* Load intra_quantiser_matrix for luminance. */
 947         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 948     }
 949     else
 950     {
 951         /* Use the default matrix. */
 952         LinkMatrix( &p_vpar->sequence.intra_quant,
 953                     pi_default_intra_quant );
 954     }
 955     if( GetBits( &p_vpar->bit_stream, 1 ) )
 956     {
 957         /* Load non_intra_quantiser_matrix for luminance. */
 958         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 959     }
 960     else
 961     {
 962         /* Use the default matrix. */
 963         LinkMatrix( &p_vpar->sequence.nonintra_quant,
 964                     pi_default_nonintra_quant );
 965     }
 966     if( GetBits( &p_vpar->bit_stream, 1 ) )
 967     {
 968         /* Load intra_quantiser_matrix for chrominance. */
 969         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
 970     }
 971     else
 972     {
 973         /* Link the chrominance intra matrix to the luminance one. */
 974         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 975                     p_vpar->sequence.intra_quant.pi_matrix );
 976     }
 977     if( GetBits( &p_vpar->bit_stream, 1 ) )
 978     {
 979         /* Load non_intra_quantiser_matrix for chrominance. */
 980         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 981     }
 982     else
 983     {
 984         /* Link the chrominance intra matrix to the luminance one. */
 985         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 986                     p_vpar->sequence.intra_quant.pi_matrix );
 987     }
 988     if( GetBits( &p_vpar->bit_stream, 1 ) )
 989     {
 990         /* Load non_intra_quantiser_matrix for chrominance. */
 991         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 992     }
 993     else
 994     {
 995         /* Link the chrominance nonintra matrix to the luminance one. */
 996         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 997                     p_vpar->sequence.nonintra_quant.pi_matrix );
 998     }
 999 }
1000
1001
1002 /*****************************************************************************
1003  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
1004  *                             structure to handle scalable coding           *
1005  *****************************************************************************/
1006
1007 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1008 {
1009     /* We don't care about anything scalable except the scalable mode. */
1010     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1011     /* The length of the structure depends on the value of the scalable_mode */
1012     {
1013         case 1:
1014             DumpBits32( &p_vpar->bit_stream );
1015             DumpBits( &p_vpar->bit_stream, 21 );
1016             break;
1017         case 2:
1018             DumpBits( &p_vpar->bit_stream, 12 );
1019             break;
1020         default:
1021             DumpBits( &p_vpar->bit_stream, 4 );
1022     }
1023
1024 }
1025 /*****************************************************************************
1026  * PictureDisplayExtension : Parse the picture_display_extension structure   *
1027  *****************************************************************************/
1028
1029 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1030 {
1031     /* Number of frame center offset */
1032     int nb;
1033     /* I am not sure it works but it should
1034         (fewer tests than shown in §6.3.12) */
1035     nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1036                                           p_vpar->picture.b_repeat_first_field +
1037                                           p_vpar->picture.b_top_field_first
1038                          : ( p_vpar->picture.b_frame_structure + 1 ) +
1039                            p_vpar->picture.b_repeat_first_field;
1040     DumpBits( &p_vpar->bit_stream, 34 * nb );
1041 }
1042
1043
1044 /*****************************************************************************
1045  * PictureSpatialScalableExtension                                           *
1046  *****************************************************************************/
1047
1048 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1049 {
1050     /* That's scalable, so we trash it */
1051     DumpBits32( &p_vpar->bit_stream );
1052     DumpBits( &p_vpar->bit_stream, 16 );
1053 }
1054
1055
1056 /*****************************************************************************
1057  * PictureTemporalScalableExtension                                          *
1058  *****************************************************************************/
1059
1060 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1061 {
1062     /* Scalable again, trashed again */
1063     DumpBits( &p_vpar->bit_stream, 23 );
1064 }
1065
1066
1067 /*****************************************************************************
1068  * CopyrightExtension : Keeps some legal informations                        *
1069  *****************************************************************************/
1070
1071 static void CopyrightExtension( vpar_thread_t * p_vpar )
1072 {
1073     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1074     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1075         /* A flag that says whether the copyright information is significant */
1076     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1077         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1078     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1079         /* Reserved bits */
1080     DumpBits( &p_vpar->bit_stream, 8 );
1081         /* The copyright_number is split in three parts */
1082         /* first part */
1083     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1084     DumpBits( &p_vpar->bit_stream, 1 );
1085         /* second part */
1086     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1087     DumpBits( &p_vpar->bit_stream, 1 );
1088         /* third part and sum */
1089     p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) +
1090                                       ( (u64)i_copyright_nb_2 << 22 ) +
1091                                       ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );
1092 }