git.sesse.net Git - vlc/blob - src/video_parser/vpar_headers.c

   1 /*****************************************************************************
   2  * vpar_headers.c : headers parsing
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: vpar_headers.c,v 1.63 2000/12/27 18:09:02 massiot Exp $
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *          Stéphane Borel <stef@via.ecp.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include "defs.h"
  29
  30 #include <stdlib.h>                                                /* free() */
  31 #include <sys/types.h>                        /* on BSD, uio.h needs types.h */
  32 #include <sys/uio.h>                                            /* "input.h" */
  33
  34 #include "config.h"
  35 #include "common.h"
  36 #include "threads.h"
  37 #include "mtime.h"
  38 #include "plugins.h"
  39
  40 #include "intf_msg.h"
  41
  42 #include "stream_control.h"
  43 #include "input_ext-dec.h"
  44
  45 #include "video.h"
  46 #include "video_output.h"
  47
  48 #include "../video_decoder/vdec_idct.h"
  49 #include "../video_decoder/video_decoder.h"
  50 #include "../video_decoder/vdec_motion.h"
  51
  52 #include "../video_decoder/vpar_blocks.h"
  53 #include "../video_decoder/vpar_headers.h"
  54 #include "../video_decoder/vpar_synchro.h"
  55 #include "../video_decoder/video_parser.h"
  56 #include "../video_decoder/video_fifo.h"
  57
  58 /*
  59  * Local prototypes
  60  */
  61 static __inline__ void NextStartCode( bit_stream_t * );
  62 static void SequenceHeader( vpar_thread_t * p_vpar );
  63 static void GroupHeader( vpar_thread_t * p_vpar );
  64 static void PictureHeader( vpar_thread_t * p_vpar );
  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  * ReferenceUpdate : Update the reference pointers when we have a new picture
 161  *****************************************************************************/
 162 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
 163                                         int i_coding_type,
 164                                         picture_t * p_newref )
 165 {
 166     if( i_coding_type != B_CODING_TYPE )
 167     {
 168         if( p_vpar->sequence.p_forward != NULL )
 169         {
 170             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
 171         }
 172         if( p_vpar->sequence.p_backward != NULL )
 173         {
 174             vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
 175                               vpar_SynchroDate( p_vpar ) );
 176         }
 177         p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
 178         p_vpar->sequence.p_backward = p_newref;
 179         if( p_newref != NULL )
 180         {
 181             vout_LinkPicture( p_vpar->p_vout, p_newref );
 182         }
 183     }
 184     else if( p_newref != NULL )
 185     {
 186         /* Put date immediately. */
 187         vout_DatePicture( p_vpar->p_vout, p_newref, vpar_SynchroDate(p_vpar) );
 188     }
 189 }
 190
 191 /*****************************************************************************
 192  * ReferenceReplace : Replace the last reference pointer when we destroy
 193  *                    a picture
 194  *****************************************************************************/
 195 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
 196                                          int i_coding_type,
 197                                          picture_t * p_newref )
 198 {
 199     if( i_coding_type != B_CODING_TYPE )
 200     {
 201         if( p_vpar->sequence.p_backward != NULL )
 202         {
 203             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
 204         }
 205         p_vpar->sequence.p_backward = p_newref;
 206         if( p_newref != NULL )
 207         {
 208             vout_LinkPicture( p_vpar->p_vout, p_newref );
 209         }
 210     }
 211 }
 212
 213 /*****************************************************************************
 214  * LoadMatrix : Load a quantization matrix
 215  *****************************************************************************/
 216 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
 217 {
 218     int i_dummy;
 219
 220     if( !p_matrix->b_allocated )
 221     {
 222         /* Allocate a piece of memory to load the matrix. */
 223         if( (p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) )) == NULL )
 224         {
 225             intf_ErrMsg( "vpar error: allocation error in LoadMatrix()" );
 226             p_vpar->p_fifo->b_error = 1;
 227             return;
 228         }
 229         p_matrix->b_allocated = 1;
 230     }
 231
 232     for( i_dummy = 0; i_dummy < 64; i_dummy++ )
 233     {
 234         p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
 235              = GetBits( &p_vpar->bit_stream, 8 );
 236     }
 237
 238 #ifdef VDEC_DFT
 239     /* Discrete Fourier Transform requires the quantization matrices to
 240      * be normalized before using them. */
 241     vdec_NormQuantMatrix( p_matrix->pi_matrix );
 242 #endif
 243 }
 244
 245 /*****************************************************************************
 246  * LinkMatrix : Link a quantization matrix to another
 247  *****************************************************************************/
 248 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
 249 {
 250     if( p_matrix->b_allocated )
 251     {
 252         /* Deallocate the piece of memory. */
 253         free( p_matrix->pi_matrix );
 254         p_matrix->b_allocated = 0;
 255     }
 256
 257     p_matrix->pi_matrix = pi_array;
 258 }
 259
 260 /*
 261  * Exported functions.
 262  */
 263
 264 /*****************************************************************************
 265  * vpar_NextSequenceHeader : Find the next sequence header
 266  *****************************************************************************/
 267 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
 268 {
 269     while( !p_vpar->p_fifo->b_die )
 270     {
 271         NextStartCode( &p_vpar->bit_stream );
 272         if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
 273         {
 274             return 0;
 275         }
 276         RemoveBits( &p_vpar->bit_stream, 8 );
 277     }
 278     return 1;
 279 }
 280
 281 /*****************************************************************************
 282  * vpar_ParseHeader : Parse the next header
 283  *****************************************************************************/
 284 int vpar_ParseHeader( vpar_thread_t * p_vpar )
 285 {
 286     while( !p_vpar->p_fifo->b_die )
 287     {
 288         NextStartCode( &p_vpar->bit_stream );
 289         switch( GetBits32( &p_vpar->bit_stream ) )
 290         {
 291         case SEQUENCE_HEADER_CODE:
 292 #ifdef STATS
 293             p_vpar->c_sequences++;
 294 #endif
 295             SequenceHeader( p_vpar );
 296             return 0;
 297             break;
 298
 299         case GROUP_START_CODE:
 300             GroupHeader( p_vpar );
 301             return 0;
 302             break;
 303
 304         case PICTURE_START_CODE:
 305             PictureHeader( p_vpar );
 306             return 0;
 307             break;
 308
 309         case SEQUENCE_END_CODE:
 310             intf_DbgMsg("vpar debug: sequence end code received");
 311             return 1;
 312             break;
 313
 314         default:
 315         }
 316     }
 317
 318     return 0;
 319 }
 320
 321 /*
 322  * Following functions are local
 323  */
 324
 325 /*****************************************************************************
 326  * SequenceHeader : Parse the next sequence header
 327  *****************************************************************************/
 328 static void SequenceHeader( vpar_thread_t * p_vpar )
 329 {
 330 #define RESERVED    -1
 331     static int i_frame_rate_table[16] =
 332     {
 333         0,
 334         23 * 1000,
 335         24 * 1001,
 336         25 * 1001,
 337         30 * 1000,
 338         30 * 1001,
 339         50 * 1001,
 340         60 * 1000,
 341         60 * 1001,
 342         RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
 343     };
 344 #undef RESERVED
 345
 346     int i_height_save, i_width_save;
 347
 348     i_height_save = p_vpar->sequence.i_height;
 349     i_width_save = p_vpar->sequence.i_width;
 350
 351     p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
 352     p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
 353     p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
 354     p_vpar->sequence.i_frame_rate =
 355             i_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
 356
 357     /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
 358      * constrained_parameters_flag */
 359     RemoveBits( &p_vpar->bit_stream, 30 );
 360
 361     /*
 362      * Quantization matrices
 363      */
 364     if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
 365     {
 366         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 367     }
 368     else
 369     {
 370         /* Use default matrix. */
 371         LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
 372     }
 373
 374     if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
 375     {
 376         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 377     }
 378     else
 379     {
 380         /* Use default matrix. */
 381         LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
 382     }
 383
 384     /* Unless later overwritten by a matrix extension, we have the same
 385      * matrices for luminance and chrominance. */
 386     LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 387                 p_vpar->sequence.intra_quant.pi_matrix );
 388     LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 389                 p_vpar->sequence.nonintra_quant.pi_matrix );
 390
 391     /*
 392      * Sequence Extension
 393      */
 394     NextStartCode( &p_vpar->bit_stream );
 395     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
 396     {
 397         int                         i_dummy;
 398
 399         /* Turn the MPEG2 flag on */
 400         p_vpar->sequence.b_mpeg2 = 1;
 401
 402         /* Parse sequence_extension */
 403         RemoveBits32( &p_vpar->bit_stream );
 404         /* extension_start_code_identifier, profile_and_level_indication */
 405         RemoveBits( &p_vpar->bit_stream, 12 );
 406         p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
 407         p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
 408         p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
 409         p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
 410         /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
 411         RemoveBits( &p_vpar->bit_stream, 22 );
 412         /* frame_rate_extension_n */
 413         i_dummy = GetBits( &p_vpar->bit_stream, 2 );
 414         /* frame_rate_extension_d */
 415         p_vpar->sequence.i_frame_rate *= (i_dummy + 1)
 416                                   / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
 417     }
 418     else
 419     {
 420         /* It's an MPEG-1 stream. Put adequate parameters. */
 421
 422         p_vpar->sequence.b_mpeg2 = 0;
 423         p_vpar->sequence.b_progressive = 1;
 424         p_vpar->sequence.i_chroma_format = CHROMA_420;
 425     }
 426
 427     /* Update sizes */
 428     p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
 429     p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
 430                                    (p_vpar->sequence.i_height + 15) / 16 :
 431                                    2 * ((p_vpar->sequence.i_height + 31) / 32);
 432     p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
 433                                         * p_vpar->sequence.i_mb_height;
 434     p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
 435     p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
 436     p_vpar->sequence.i_size = p_vpar->sequence.i_width
 437                                         * p_vpar->sequence.i_height;
 438
 439     /* Update chromatic information. */
 440     switch( p_vpar->sequence.i_chroma_format )
 441     {
 442     case CHROMA_420:
 443         p_vpar->sequence.i_chroma_nb_blocks = 2;
 444         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
 445         p_vpar->sequence.i_chroma_mb_width = 8;
 446         p_vpar->sequence.i_chroma_mb_height = 8;
 447         break;
 448
 449     case CHROMA_422:
 450         p_vpar->sequence.i_chroma_nb_blocks = 4;
 451         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
 452         p_vpar->sequence.i_chroma_mb_width = 8;
 453         p_vpar->sequence.i_chroma_mb_height = 16;
 454         break;
 455
 456     case CHROMA_444:
 457         p_vpar->sequence.i_chroma_nb_blocks = 8;
 458         p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
 459         p_vpar->sequence.i_chroma_mb_width = 16;
 460         p_vpar->sequence.i_chroma_mb_height = 16;
 461     }
 462
 463     /* Reset scalable_mode. */
 464     p_vpar->sequence.i_scalable_mode = SC_NONE;
 465
 466 #if 0
 467     if(    p_vpar->sequence.i_width != i_width_save
 468         || p_vpar->sequence.i_height != i_height_save )
 469     {
 470          /* FIXME: What do we do in case of a size change ?? */
 471     }
 472 #endif
 473
 474     /* Extension and User data */
 475     ExtensionAndUserData( p_vpar );
 476 }
 477
 478 /*****************************************************************************
 479  * GroupHeader : Parse the next group of pictures header
 480  *****************************************************************************/
 481 static void GroupHeader( vpar_thread_t * p_vpar )
 482 {
 483     /* Nothing to do, we don't care. */
 484     RemoveBits( &p_vpar->bit_stream, 27 );
 485     ExtensionAndUserData( p_vpar );
 486 }
 487
 488 /*****************************************************************************
 489  * PictureHeader : Parse the next picture header
 490  *****************************************************************************/
 491 static void PictureHeader( vpar_thread_t * p_vpar )
 492 {
 493     int                 i_structure;
 494     int                 i_mb_base;
 495     boolean_t           b_parsable;
 496 #ifdef VDEC_SMP
 497     int                 i_mb;
 498 #endif
 499
 500     RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
 501     p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
 502     RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
 503
 504     if( p_vpar->picture.i_coding_type == P_CODING_TYPE
 505         || p_vpar->picture.i_coding_type == B_CODING_TYPE )
 506     {
 507         p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
 508         p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
 509     }
 510     if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
 511     {
 512         p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
 513         p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
 514     }
 515
 516     /* extra_information_picture */
 517     while( GetBits( &p_vpar->bit_stream, 1 ) )
 518     {
 519         RemoveBits( &p_vpar->bit_stream, 8 );
 520     }
 521
 522     /*
 523      * Picture Coding Extension
 524      */
 525     NextStartCode( &p_vpar->bit_stream );
 526     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
 527     {
 528         /* Parse picture_coding_extension */
 529         RemoveBits32( &p_vpar->bit_stream );
 530         /* extension_start_code_identifier */
 531         RemoveBits( &p_vpar->bit_stream, 4 );
 532
 533         p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
 534         p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
 535         p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
 536         p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
 537         p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
 538         i_structure = GetBits( &p_vpar->bit_stream, 2 );
 539         p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
 540         p_vpar->picture.b_frame_pred_frame_dct
 541              = GetBits( &p_vpar->bit_stream, 1 );
 542         p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
 543         p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
 544         p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
 545         p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
 546         p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
 547         /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
 548          * the length of the picture_display_extension structure.
 549          * chroma_420_type (obsolete) */
 550         RemoveBits( &p_vpar->bit_stream, 1 );
 551         p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
 552
 553         /* composite_display_flag */
 554         if( GetBits( &p_vpar->bit_stream, 1 ) )
 555         {
 556             /* v_axis, field_sequence, sub_carrier, burst_amplitude,
 557              * sub_carrier_phase */
 558             RemoveBits( &p_vpar->bit_stream, 20 );
 559         }
 560     }
 561     else
 562     {
 563         /* MPEG-1 compatibility flags */
 564         p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
 565         i_structure = FRAME_STRUCTURE;
 566         p_vpar->picture.b_frame_pred_frame_dct = 1;
 567         p_vpar->picture.b_concealment_mv = 0;
 568         p_vpar->picture.b_q_scale_type = 0;
 569         p_vpar->picture.b_intra_vlc_format = 0;
 570         p_vpar->picture.b_alternate_scan = 0; /* zigzag */
 571         p_vpar->picture.b_repeat_first_field = 0;
 572         p_vpar->picture.b_progressive_frame = 1;
 573     }
 574
 575 #ifdef STATS
 576     p_vpar->pc_pictures[p_vpar->picture.i_coding_type]++;
 577 #endif
 578
 579     if( p_vpar->picture.i_current_structure &&
 580         (i_structure == FRAME_STRUCTURE ||
 581          i_structure == p_vpar->picture.i_current_structure) )
 582     {
 583         /* We don't have the second field of the buffered frame. */
 584         if( p_vpar->picture.p_picture != NULL )
 585         {
 586             ReferenceReplace( p_vpar,
 587                       p_vpar->picture.i_coding_type,
 588                       NULL );
 589
 590 #ifdef VDEC_SMP
 591             for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
 592             {
 593                 vpar_DestroyMacroblock( &p_vpar->vfifo,
 594                                         p_vpar->picture.pp_mb[i_mb] );
 595             }
 596 #endif
 597             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
 598         }
 599
 600         p_vpar->picture.i_current_structure = 0;
 601
 602         intf_DbgMsg("vpar debug: odd number of field picture.");
 603     }
 604
 605     /* Do we have the reference pictures ? */
 606     b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
 607                     (p_vpar->sequence.p_backward == NULL)) ||
 608                      /* p_backward will become p_forward later */
 609                    ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
 610                     (p_vpar->sequence.p_forward == NULL ||
 611                      p_vpar->sequence.p_backward == NULL)));
 612
 613     if( b_parsable )
 614     {
 615         if( p_vpar->picture.i_current_structure )
 616         {
 617             /* Second field of a frame. We will decode it if, and only if we
 618              * have decoded the first field. */
 619             b_parsable = (p_vpar->picture.p_picture != NULL);
 620         }
 621         else
 622         {
 623             /* Warn synchro we have a new picture (updates pictures index). */
 624             vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type );
 625
 626             /* Does synchro say we have enough time to decode it ? */
 627             b_parsable = vpar_SynchroChoose( p_vpar,
 628                                p_vpar->picture.i_coding_type, i_structure );
 629         }
 630     }
 631
 632     if( !b_parsable )
 633     {
 634         /* Update the reference pointers. */
 635         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
 636
 637         /* Update context. */
 638         if( i_structure != FRAME_STRUCTURE )
 639         {
 640             if( (p_vpar->picture.i_current_structure | i_structure)
 641                     == FRAME_STRUCTURE )
 642             {
 643                 p_vpar->picture.i_current_structure = 0;
 644             }
 645             else
 646             {
 647                 /* The frame is complete. */
 648                 p_vpar->picture.i_current_structure = i_structure;
 649
 650                 vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type );
 651                 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 652             }
 653         }
 654         else
 655         {
 656             /* Warn Synchro we have trashed a picture. */
 657             vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type );
 658             vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 659         }
 660         p_vpar->picture.p_picture = NULL;
 661
 662         return;
 663     }
 664
 665     /* OK, now we are sure we will decode the picture. */
 666 #ifdef STATS
 667     p_vpar->pc_decoded_pictures[p_vpar->picture.i_coding_type]++;
 668 #endif
 669
 670 #define P_picture p_vpar->picture.p_picture
 671     p_vpar->picture.b_error = 0;
 672     p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
 673
 674     if( !p_vpar->picture.i_current_structure )
 675     {
 676         /* This is a new frame. Get a structure from the video_output. */
 677         while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
 678                                         99+p_vpar->sequence.i_chroma_format, /*XXX??*/
 679                                         p_vpar->sequence.i_width,
 680                                         p_vpar->sequence.i_height ) )
 681              == NULL )
 682         {
 683             intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying");
 684             if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
 685             {
 686                 return;
 687             }
 688             msleep( VPAR_OUTMEM_SLEEP );
 689         }
 690
 691         /* Initialize values. */
 692         vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 693         P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
 694         P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
 695         p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
 696                     << ( 1 - p_vpar->picture.b_frame_structure ) );
 697         p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
 698                     << ( 1 - p_vpar->picture.b_frame_structure ));
 699
 700         P_picture->i_deccount = p_vpar->sequence.i_mb_size;
 701         vlc_mutex_init( &p_vpar->picture.p_picture->lock_deccount );
 702 #ifdef VDEC_SMP
 703         memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
 704 #endif
 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 #ifdef VDEC_SMP
 712         /* Link referenced pictures for the decoder
 713          * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
 714         if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
 715             p_vpar->picture.i_coding_type == B_CODING_TYPE )
 716         {
 717             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
 718         }
 719         if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
 720         {
 721             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
 722         }
 723 #endif
 724     }
 725     p_vpar->picture.i_current_structure |= i_structure;
 726     p_vpar->picture.i_structure = i_structure;
 727
 728     /* Initialize picture data for decoding. */
 729     if( i_structure == BOTTOM_FIELD )
 730     {
 731         i_mb_base = p_vpar->sequence.i_mb_size >> 1;
 732         p_vpar->mb.i_l_y = 1;
 733         p_vpar->mb.i_c_y = 1;
 734     }
 735     else
 736     {
 737         i_mb_base = 0;
 738         p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
 739     }
 740     p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
 741
 742     /* Extension and User data. */
 743     ExtensionAndUserData( p_vpar );
 744
 745     vpar_PictureData( p_vpar, i_mb_base );
 746
 747     if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
 748     {
 749         return;
 750     }
 751
 752     if( p_vpar->picture.b_error )
 753     {
 754         /* Trash picture. */
 755 //fprintf(stderr, "Image trashee\n");
 756 #ifdef VDEC_SMP
 757         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
 758         {
 759             vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 760         }
 761 #endif
 762
 763 #ifdef STATS
 764         p_vpar->pc_malformed_pictures[p_vpar->picture.i_coding_type]++;
 765 #endif
 766
 767         if( P_picture->i_deccount != 1 )
 768         {
 769             vpar_SynchroEnd( p_vpar, 1 );
 770             vout_DestroyPicture( p_vpar->p_vout, P_picture );
 771         }
 772
 773         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
 774
 775         /* Prepare context for the next picture. */
 776         P_picture = NULL;
 777         if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 778             p_vpar->picture.i_current_structure = 0;
 779     }
 780     else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 781     {
 782 //fprintf(stderr, "Image parsee (%d)\n", p_vpar->picture.i_coding_type);
 783         /* Frame completely parsed. */
 784 #ifdef VDEC_SMP
 785         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
 786         {
 787             vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 788         }
 789
 790         /* Send signal to the video_decoder. */
 791         vlc_mutex_lock( &p_vpar->vfifo.lock );
 792         vlc_cond_signal( &p_vpar->vfifo.wait );
 793         vlc_mutex_unlock( &p_vpar->vfifo.lock );
 794 #endif
 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  * ExtensionAndUserData : Parse the extension_and_user_data structure
 805  *****************************************************************************/
 806 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
 807 {
 808     while( !p_vpar->p_fifo->b_die )
 809     {
 810         NextStartCode( &p_vpar->bit_stream );
 811         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
 812         {
 813         case EXTENSION_START_CODE:
 814             RemoveBits32( &p_vpar->bit_stream );
 815             switch( GetBits( &p_vpar->bit_stream, 4 ) )
 816             {
 817             case SEQUENCE_DISPLAY_EXTENSION_ID:
 818                 SequenceDisplayExtension( p_vpar );
 819                 break;
 820             case QUANT_MATRIX_EXTENSION_ID:
 821                 QuantMatrixExtension( p_vpar );
 822                 break;
 823             case SEQUENCE_SCALABLE_EXTENSION_ID:
 824                 SequenceScalableExtension( p_vpar );
 825                 break;
 826             case PICTURE_DISPLAY_EXTENSION_ID:
 827                 PictureDisplayExtension( p_vpar );
 828                 break;
 829             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
 830                 PictureSpatialScalableExtension( p_vpar );
 831                 break;
 832             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
 833                 PictureTemporalScalableExtension( p_vpar );
 834                 break;
 835             case COPYRIGHT_EXTENSION_ID:
 836                 CopyrightExtension( p_vpar );
 837                 break;
 838             default:
 839             }
 840             break;
 841
 842         case USER_DATA_START_CODE:
 843             RemoveBits32( &p_vpar->bit_stream );
 844             /* Wait for the next start code */
 845             break;
 846
 847         default:
 848             return;
 849         }
 850     }
 851 }
 852
 853
 854 /*****************************************************************************
 855  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
 856  *****************************************************************************/
 857
 858 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
 859 {
 860     /* We don't care sequence_display_extension. */
 861     /* video_format */
 862     RemoveBits( &p_vpar->bit_stream, 3 );
 863     if( GetBits( &p_vpar->bit_stream, 1 ) )
 864     {
 865         /* Two bytes for color_desciption */
 866         RemoveBits( &p_vpar->bit_stream, 16 );
 867         p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
 868     }
 869     /* display_horizontal and vertical_size and a marker_bit */
 870     RemoveBits( &p_vpar->bit_stream, 29 );
 871 }
 872
 873
 874 /*****************************************************************************
 875  * QuantMatrixExtension : Load quantization matrices for luminance           *
 876  *                        and chrominance                                    *
 877  *****************************************************************************/
 878
 879 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
 880 {
 881     if( GetBits( &p_vpar->bit_stream, 1 ) )
 882     {
 883         /* Load intra_quantiser_matrix for luminance. */
 884         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 885     }
 886     else
 887     {
 888         /* Use the default matrix. */
 889         LinkMatrix( &p_vpar->sequence.intra_quant,
 890                     pi_default_intra_quant );
 891     }
 892     if( GetBits( &p_vpar->bit_stream, 1 ) )
 893     {
 894         /* Load non_intra_quantiser_matrix for luminance. */
 895         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 896     }
 897     else
 898     {
 899         /* Use the default matrix. */
 900         LinkMatrix( &p_vpar->sequence.nonintra_quant,
 901                     pi_default_nonintra_quant );
 902     }
 903     if( GetBits( &p_vpar->bit_stream, 1 ) )
 904     {
 905         /* Load intra_quantiser_matrix for chrominance. */
 906         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
 907     }
 908     else
 909     {
 910         /* Link the chrominance intra matrix to the luminance one. */
 911         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 912                     p_vpar->sequence.intra_quant.pi_matrix );
 913     }
 914     if( GetBits( &p_vpar->bit_stream, 1 ) )
 915     {
 916         /* Load non_intra_quantiser_matrix for chrominance. */
 917         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 918     }
 919     else
 920     {
 921         /* Link the chrominance intra matrix to the luminance one. */
 922         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 923                     p_vpar->sequence.intra_quant.pi_matrix );
 924     }
 925     if( GetBits( &p_vpar->bit_stream, 1 ) )
 926     {
 927         /* Load non_intra_quantiser_matrix for chrominance. */
 928         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 929     }
 930     else
 931     {
 932         /* Link the chrominance nonintra matrix to the luminance one. */
 933         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 934                     p_vpar->sequence.nonintra_quant.pi_matrix );
 935     }
 936 }
 937
 938
 939 /*****************************************************************************
 940  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
 941  *                             structure to handle scalable coding           *
 942  *****************************************************************************/
 943
 944 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
 945 {
 946     /* We don't care about anything scalable except the scalable mode. */
 947     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
 948     /* The length of the structure depends on the value of the scalable_mode */
 949     {
 950         case 1:
 951             RemoveBits32( &p_vpar->bit_stream );
 952             RemoveBits( &p_vpar->bit_stream, 21 );
 953             break;
 954         case 2:
 955             RemoveBits( &p_vpar->bit_stream, 12 );
 956             break;
 957         default:
 958             RemoveBits( &p_vpar->bit_stream, 4 );
 959     }
 960
 961 }
 962 /*****************************************************************************
 963  * PictureDisplayExtension : Parse the picture_display_extension structure   *
 964  *****************************************************************************/
 965
 966 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
 967 {
 968     /* Number of frame center offset */
 969     int i_nb, i_dummy;
 970     /* I am not sure it works but it should
 971         (fewer tests than shown in §6.3.12) */
 972     i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
 973                                             p_vpar->picture.b_repeat_first_field +
 974                                             p_vpar->picture.b_top_field_first
 975                            : ( p_vpar->picture.b_frame_structure + 1 ) +
 976                              p_vpar->picture.b_repeat_first_field;
 977     for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
 978     {
 979         RemoveBits( &p_vpar->bit_stream, 17 );
 980         RemoveBits( &p_vpar->bit_stream, 17 );
 981     }
 982 }
 983
 984
 985 /*****************************************************************************
 986  * PictureSpatialScalableExtension                                           *
 987  *****************************************************************************/
 988
 989 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
 990 {
 991     /* That's scalable, so we trash it */
 992     RemoveBits32( &p_vpar->bit_stream );
 993     RemoveBits( &p_vpar->bit_stream, 16 );
 994 }
 995
 996
 997 /*****************************************************************************
 998  * PictureTemporalScalableExtension                                          *
 999  *****************************************************************************/
1000
1001 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1002 {
1003     /* Scalable again, trashed again */
1004     RemoveBits( &p_vpar->bit_stream, 23 );
1005 }
1006
1007
1008 /*****************************************************************************
1009  * CopyrightExtension : Keeps some legal informations                        *
1010  *****************************************************************************/
1011
1012 static void CopyrightExtension( vpar_thread_t * p_vpar )
1013 {
1014     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1015     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1016         /* A flag that says whether the copyright information is significant */
1017     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1018         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1019     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1020         /* Reserved bits */
1021     RemoveBits( &p_vpar->bit_stream, 8 );
1022         /* The copyright_number is split in three parts */
1023         /* first part */
1024     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1025     RemoveBits( &p_vpar->bit_stream, 1 );
1026         /* second part */
1027     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1028     RemoveBits( &p_vpar->bit_stream, 1 );
1029         /* third part and sum */
1030     p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1031                                       ( (u64)i_copyright_nb_2 << 22 ) |
1032                                       ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );
1033 }