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