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