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.72 2001/01/16 18:06:01 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
  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.h"
  47 #include "../video_decoder/vdec_idct.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         /* chroma_420_type (obsolete) */
 546         RemoveBits( &p_vpar->bit_stream, 1 );
 547         p_vpar->picture.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
 548
 549         /* composite_display_flag */
 550         if( GetBits( &p_vpar->bit_stream, 1 ) )
 551         {
 552             /* v_axis, field_sequence, sub_carrier, burst_amplitude,
 553              * sub_carrier_phase */
 554             RemoveBits( &p_vpar->bit_stream, 20 );
 555         }
 556     }
 557     else
 558     {
 559         /* MPEG-1 compatibility flags */
 560         p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
 561         i_structure = FRAME_STRUCTURE;
 562         p_vpar->picture.b_top_field_first = 0;
 563         p_vpar->picture.b_frame_pred_frame_dct = 1;
 564         p_vpar->picture.b_concealment_mv = 0;
 565         p_vpar->picture.b_q_scale_type = 0;
 566         p_vpar->picture.b_intra_vlc_format = 0;
 567         p_vpar->picture.b_alternate_scan = 0; /* zigzag */
 568         p_vpar->picture.b_repeat_first_field = 1; /* FIXME! this contradicts
 569                                                    * ISO/IEC */
 570         p_vpar->picture.b_progressive = 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         int     i_repeat_field;
 623
 624         /* Compute the number of times the frame will be emitted by the
 625          * decoder (number of periods). */
 626         if( p_vpar->sequence.b_progressive )
 627         {
 628             i_repeat_field = 1 + p_vpar->picture.b_repeat_first_field
 629                                + p_vpar->picture.b_top_field_first;
 630         }
 631         else
 632         {
 633             if( p_vpar->picture.b_progressive )
 634             {
 635                 i_repeat_field = 2 + p_vpar->picture.b_repeat_first_field;
 636             }
 637             else
 638             {
 639                 i_repeat_field = 2;
 640             }
 641         }
 642
 643         /* Warn synchro we have a new picture (updates pictures index). */
 644         vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type,
 645                                 i_repeat_field );
 646
 647         if( b_parsable )
 648         {
 649             /* Does synchro say we have enough time to decode it ? */
 650             b_parsable = vpar_SynchroChoose( p_vpar,
 651                                p_vpar->picture.i_coding_type, i_structure );
 652         }
 653     }
 654
 655     if( !b_parsable )
 656     {
 657         /* Update the reference pointers. */
 658         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
 659
 660         /* Update context. */
 661         if( i_structure != FRAME_STRUCTURE )
 662         {
 663             if( (p_vpar->picture.i_current_structure | i_structure)
 664                     == FRAME_STRUCTURE )
 665             {
 666                 p_vpar->picture.i_current_structure = 0;
 667             }
 668             else
 669             {
 670                 /* The frame is complete. */
 671                 p_vpar->picture.i_current_structure = i_structure;
 672
 673                 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 674             }
 675         }
 676         else
 677         {
 678             /* Warn Synchro we have trashed a picture. */
 679             vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 680         }
 681         p_vpar->picture.p_picture = NULL;
 682
 683         return;
 684     }
 685
 686     /* OK, now we are sure we will decode the picture. */
 687 #ifdef STATS
 688     p_vpar->pc_decoded_pictures[p_vpar->picture.i_coding_type]++;
 689 #endif
 690
 691 #define P_picture p_vpar->picture.p_picture
 692     p_vpar->picture.b_error = 0;
 693     p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
 694
 695     if( !p_vpar->picture.i_current_structure )
 696     {
 697         /* This is a new frame. Get a structure from the video_output. */
 698         while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
 699                                         99+p_vpar->sequence.i_chroma_format, /*XXX??*/
 700                                         p_vpar->sequence.i_width,
 701                                         p_vpar->sequence.i_height ) )
 702              == NULL )
 703         {
 704             intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying");
 705             if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
 706             {
 707                 return;
 708             }
 709             msleep( VPAR_OUTMEM_SLEEP );
 710         }
 711
 712         /* Initialize values. */
 713         vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 714         P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
 715         P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
 716         p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
 717                     << ( 1 - p_vpar->picture.b_frame_structure ) );
 718         p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
 719                     << ( 1 - p_vpar->picture.b_frame_structure ));
 720
 721         P_picture->i_deccount = p_vpar->sequence.i_mb_size;
 722 #ifdef VDEC_SMP
 723         memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
 724 #endif
 725 /* FIXME ! remove asap ?? */
 726 //memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
 727
 728         /* Update the reference pointers. */
 729         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
 730
 731 #ifdef VDEC_SMP
 732         /* Link referenced pictures for the decoder
 733          * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
 734         if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
 735             p_vpar->picture.i_coding_type == B_CODING_TYPE )
 736         {
 737             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
 738         }
 739         if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
 740         {
 741             vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
 742         }
 743 #endif
 744     }
 745     p_vpar->picture.i_current_structure |= i_structure;
 746     p_vpar->picture.i_structure = i_structure;
 747
 748     /* Initialize picture data for decoding. */
 749     if( i_structure == BOTTOM_FIELD )
 750     {
 751         i_mb_base = p_vpar->sequence.i_mb_size >> 1;
 752         p_vpar->mb.i_l_y = 1;
 753         p_vpar->mb.i_c_y = 1;
 754     }
 755     else
 756     {
 757         i_mb_base = 0;
 758         p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
 759     }
 760     p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
 761
 762     /* Extension and User data. */
 763     ExtensionAndUserData( p_vpar );
 764
 765     vpar_PictureData( p_vpar, i_mb_base );
 766
 767     if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
 768     {
 769         return;
 770     }
 771
 772     if( p_vpar->picture.b_error )
 773     {
 774         /* Trash picture. */
 775 #ifdef VDEC_SMP
 776         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
 777         {
 778             vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 779         }
 780 #endif
 781
 782 #ifdef STATS
 783         p_vpar->pc_malformed_pictures[p_vpar->picture.i_coding_type]++;
 784 #endif
 785
 786         if( P_picture->i_deccount != 1 )
 787         {
 788             vpar_SynchroEnd( p_vpar, 1 );
 789             vout_DestroyPicture( p_vpar->p_vout, P_picture );
 790         }
 791
 792         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
 793
 794         /* Prepare context for the next picture. */
 795         P_picture = NULL;
 796         if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 797             p_vpar->picture.i_current_structure = 0;
 798     }
 799     else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 800     {
 801         /* Frame completely parsed. */
 802 #ifdef VDEC_SMP
 803         for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
 804         {
 805             vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
 806         }
 807
 808         /* Send signal to the video_decoder. */
 809         vlc_mutex_lock( &p_vpar->vfifo.lock );
 810         vlc_cond_signal( &p_vpar->vfifo.wait );
 811         vlc_mutex_unlock( &p_vpar->vfifo.lock );
 812 #endif
 813
 814         /* Prepare context for the next picture. */
 815         P_picture = NULL;
 816         p_vpar->picture.i_current_structure = 0;
 817     }
 818 #undef P_picture
 819 }
 820
 821 /*****************************************************************************
 822  * ExtensionAndUserData : Parse the extension_and_user_data structure
 823  *****************************************************************************/
 824 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
 825 {
 826     while( !p_vpar->p_fifo->b_die )
 827     {
 828         NextStartCode( &p_vpar->bit_stream );
 829         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
 830         {
 831         case EXTENSION_START_CODE:
 832             RemoveBits32( &p_vpar->bit_stream );
 833             switch( GetBits( &p_vpar->bit_stream, 4 ) )
 834             {
 835             case SEQUENCE_DISPLAY_EXTENSION_ID:
 836                 SequenceDisplayExtension( p_vpar );
 837                 break;
 838             case QUANT_MATRIX_EXTENSION_ID:
 839                 QuantMatrixExtension( p_vpar );
 840                 break;
 841             case SEQUENCE_SCALABLE_EXTENSION_ID:
 842                 SequenceScalableExtension( p_vpar );
 843                 break;
 844             case PICTURE_DISPLAY_EXTENSION_ID:
 845                 PictureDisplayExtension( p_vpar );
 846                 break;
 847             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
 848                 PictureSpatialScalableExtension( p_vpar );
 849                 break;
 850             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
 851                 PictureTemporalScalableExtension( p_vpar );
 852                 break;
 853             case COPYRIGHT_EXTENSION_ID:
 854                 CopyrightExtension( p_vpar );
 855                 break;
 856             default:
 857             }
 858             break;
 859
 860         case USER_DATA_START_CODE:
 861             RemoveBits32( &p_vpar->bit_stream );
 862             /* Wait for the next start code */
 863             break;
 864
 865         default:
 866             return;
 867         }
 868     }
 869 }
 870
 871
 872 /*****************************************************************************
 873  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
 874  *****************************************************************************/
 875
 876 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
 877 {
 878     /* We don't care sequence_display_extension. */
 879     /* video_format */
 880     RemoveBits( &p_vpar->bit_stream, 3 );
 881     if( GetBits( &p_vpar->bit_stream, 1 ) )
 882     {
 883         /* Two bytes for color_desciption */
 884         RemoveBits( &p_vpar->bit_stream, 16 );
 885         p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
 886     }
 887     /* display_horizontal and vertical_size and a marker_bit */
 888     RemoveBits( &p_vpar->bit_stream, 29 );
 889 }
 890
 891
 892 /*****************************************************************************
 893  * QuantMatrixExtension : Load quantization matrices for luminance           *
 894  *                        and chrominance                                    *
 895  *****************************************************************************/
 896
 897 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
 898 {
 899     if( GetBits( &p_vpar->bit_stream, 1 ) )
 900     {
 901         /* Load intra_quantiser_matrix for luminance. */
 902         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 903     }
 904     else
 905     {
 906         /* Use the default matrix. */
 907         LinkMatrix( &p_vpar->sequence.intra_quant,
 908                     pi_default_intra_quant );
 909     }
 910     if( GetBits( &p_vpar->bit_stream, 1 ) )
 911     {
 912         /* Load non_intra_quantiser_matrix for luminance. */
 913         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 914     }
 915     else
 916     {
 917         /* Use the default matrix. */
 918         LinkMatrix( &p_vpar->sequence.nonintra_quant,
 919                     pi_default_nonintra_quant );
 920     }
 921     if( GetBits( &p_vpar->bit_stream, 1 ) )
 922     {
 923         /* Load intra_quantiser_matrix for chrominance. */
 924         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
 925     }
 926     else
 927     {
 928         /* Link the chrominance intra matrix to the luminance one. */
 929         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 930                     p_vpar->sequence.intra_quant.pi_matrix );
 931     }
 932     if( GetBits( &p_vpar->bit_stream, 1 ) )
 933     {
 934         /* Load non_intra_quantiser_matrix for chrominance. */
 935         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 936     }
 937     else
 938     {
 939         /* Link the chrominance intra matrix to the luminance one. */
 940         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 941                     p_vpar->sequence.intra_quant.pi_matrix );
 942     }
 943     if( GetBits( &p_vpar->bit_stream, 1 ) )
 944     {
 945         /* Load non_intra_quantiser_matrix for chrominance. */
 946         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 947     }
 948     else
 949     {
 950         /* Link the chrominance nonintra matrix to the luminance one. */
 951         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 952                     p_vpar->sequence.nonintra_quant.pi_matrix );
 953     }
 954 }
 955
 956
 957 /*****************************************************************************
 958  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
 959  *                             structure to handle scalable coding           *
 960  *****************************************************************************/
 961
 962 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
 963 {
 964     /* We don't care about anything scalable except the scalable mode. */
 965     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
 966     /* The length of the structure depends on the value of the scalable_mode */
 967     {
 968         case 1:
 969             RemoveBits32( &p_vpar->bit_stream );
 970             RemoveBits( &p_vpar->bit_stream, 21 );
 971             break;
 972         case 2:
 973             RemoveBits( &p_vpar->bit_stream, 12 );
 974             break;
 975         default:
 976             RemoveBits( &p_vpar->bit_stream, 4 );
 977     }
 978
 979 }
 980 /*****************************************************************************
 981  * PictureDisplayExtension : Parse the picture_display_extension structure   *
 982  *****************************************************************************/
 983
 984 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
 985 {
 986     /* Number of frame center offset */
 987     int i_nb, i_dummy;
 988     /* I am not sure it works but it should
 989         (fewer tests than shown in §6.3.12) */
 990     i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
 991                                             p_vpar->picture.b_repeat_first_field +
 992                                             p_vpar->picture.b_top_field_first
 993                            : ( p_vpar->picture.b_frame_structure + 1 ) +
 994                              p_vpar->picture.b_repeat_first_field;
 995     for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
 996     {
 997         RemoveBits( &p_vpar->bit_stream, 17 );
 998         RemoveBits( &p_vpar->bit_stream, 17 );
 999     }
1000 }
1001
1002
1003 /*****************************************************************************
1004  * PictureSpatialScalableExtension                                           *
1005  *****************************************************************************/
1006
1007 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1008 {
1009     /* That's scalable, so we trash it */
1010     RemoveBits32( &p_vpar->bit_stream );
1011     RemoveBits( &p_vpar->bit_stream, 16 );
1012 }
1013
1014
1015 /*****************************************************************************
1016  * PictureTemporalScalableExtension                                          *
1017  *****************************************************************************/
1018
1019 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1020 {
1021     /* Scalable again, trashed again */
1022     RemoveBits( &p_vpar->bit_stream, 23 );
1023 }
1024
1025
1026 /*****************************************************************************
1027  * CopyrightExtension : Keeps some legal informations                        *
1028  *****************************************************************************/
1029
1030 static void CopyrightExtension( vpar_thread_t * p_vpar )
1031 {
1032     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1033     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1034         /* A flag that says whether the copyright information is significant */
1035     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1036         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1037     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1038         /* Reserved bits */
1039     RemoveBits( &p_vpar->bit_stream, 8 );
1040         /* The copyright_number is split in three parts */
1041         /* first part */
1042     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1043     RemoveBits( &p_vpar->bit_stream, 1 );
1044         /* second part */
1045     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1046     RemoveBits( &p_vpar->bit_stream, 1 );
1047         /* third part and sum */
1048     p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1049                                       ( (u64)i_copyright_nb_2 << 22 ) |
1050                                       ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );
1051 }