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