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