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

   1 /*****************************************************************************
   2  * vpar_headers.c : headers parsing
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: vpar_headers.c,v 1.8 2001/09/06 13:16:26 massiot Exp $
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *          Stéphane Borel <stef@via.ecp.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include "defs.h"
  29
  30 #include <stdlib.h>                                                /* free() */
  31 #include <string.h>                                    /* memcpy(), memset() */
  32
  33 #include "config.h"
  34 #include "common.h"
  35 #include "threads.h"
  36 #include "mtime.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 "vdec_ext-plugins.h"
  47 #include "vpar_pool.h"
  48 #include "video_parser.h"
  49
  50 /*
  51  * Local prototypes
  52  */
  53 static __inline__ void NextStartCode( bit_stream_t * );
  54 static void SequenceHeader( vpar_thread_t * p_vpar );
  55 static void GroupHeader( vpar_thread_t * p_vpar );
  56 static void PictureHeader( vpar_thread_t * p_vpar );
  57 static void ExtensionAndUserData( vpar_thread_t * p_vpar );
  58 static void QuantMatrixExtension( vpar_thread_t * p_vpar );
  59 static void SequenceScalableExtension( vpar_thread_t * p_vpar );
  60 static void SequenceDisplayExtension( vpar_thread_t * p_vpar );
  61 static void PictureDisplayExtension( vpar_thread_t * p_vpar );
  62 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar );
  63 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar );
  64 static void CopyrightExtension( vpar_thread_t * p_vpar );
  65
  66 /*
  67  * Standard variables
  68  */
  69
  70 /*****************************************************************************
  71  * pi_default_intra_quant : default quantization matrix
  72  *****************************************************************************/
  73 u8 pi_default_intra_quant[] ATTR_ALIGN(16) =
  74 {
  75     8,  16, 19, 22, 26, 27, 29, 34,
  76     16, 16, 22, 24, 27, 29, 34, 37,
  77     19, 22, 26, 27, 29, 34, 34, 38,
  78     22, 22, 26, 27, 29, 34, 37, 40,
  79     22, 26, 27, 29, 32, 35, 40, 48,
  80     26, 27, 29, 32, 35, 40, 48, 58,
  81     26, 27, 29, 34, 38, 46, 56, 69,
  82     27, 29, 35, 38, 46, 56, 69, 83
  83 };
  84
  85 /*****************************************************************************
  86  * pi_default_nonintra_quant : default quantization matrix
  87  *****************************************************************************/
  88 u8 pi_default_nonintra_quant[] ATTR_ALIGN(16) =
  89 {
  90     16, 16, 16, 16, 16, 16, 16, 16,
  91     16, 16, 16, 16, 16, 16, 16, 16,
  92     16, 16, 16, 16, 16, 16, 16, 16,
  93     16, 16, 16, 16, 16, 16, 16, 16,
  94     16, 16, 16, 16, 16, 16, 16, 16,
  95     16, 16, 16, 16, 16, 16, 16, 16,
  96     16, 16, 16, 16, 16, 16, 16, 16,
  97     16, 16, 16, 16, 16, 16, 16, 16
  98 };
  99
 100 /*****************************************************************************
 101  * pi_scan : zig-zag and alternate scan patterns
 102  *****************************************************************************/
 103 u8 pi_scan[2][64] ATTR_ALIGN(16) =
 104 {
 105     { /* Zig-Zag pattern */
 106         0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
 107         12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
 108         35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
 109         58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
 110     },
 111     { /* Alternate scan pattern */
 112         0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
 113         41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
 114         51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
 115         53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
 116     }
 117 };
 118
 119 /*
 120  * Local inline functions.
 121  */
 122
 123 /*****************************************************************************
 124  * ReferenceUpdate : Update the reference pointers when we have a new picture
 125  *****************************************************************************/
 126 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
 127                                         int i_coding_type,
 128                                         picture_t * p_newref )
 129 {
 130     if( i_coding_type != B_CODING_TYPE )
 131     {
 132         if( p_vpar->sequence.p_forward != NULL )
 133         {
 134             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
 135         }
 136         if( p_vpar->sequence.p_backward != NULL )
 137         {
 138             vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
 139                               vpar_SynchroDate( p_vpar ) );
 140         }
 141         p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
 142         p_vpar->sequence.p_backward = p_newref;
 143         if( p_newref != NULL )
 144         {
 145             vout_LinkPicture( p_vpar->p_vout, p_newref );
 146         }
 147     }
 148     else if( p_newref != NULL )
 149     {
 150         /* Put date immediately. */
 151         vout_DatePicture( p_vpar->p_vout, p_newref, vpar_SynchroDate(p_vpar) );
 152     }
 153 }
 154
 155 /*****************************************************************************
 156  * ReferenceReplace : Replace the last reference pointer when we destroy
 157  *                    a picture
 158  *****************************************************************************/
 159 static void __inline__ ReferenceReplace( 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_backward != NULL )
 166         {
 167             vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
 168         }
 169         p_vpar->sequence.p_backward = p_newref;
 170         if( p_newref != NULL )
 171         {
 172             vout_LinkPicture( p_vpar->p_vout, p_newref );
 173         }
 174     }
 175 }
 176
 177 /*****************************************************************************
 178  * LoadMatrix : Load a quantization matrix
 179  *****************************************************************************/
 180 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar,
 181                                    quant_matrix_t * p_matrix )
 182 {
 183     int i_dummy;
 184
 185     if( !p_matrix->b_allocated )
 186     {
 187         /* Allocate a piece of memory to load the matrix. */
 188         if( (p_matrix->pi_matrix = (u8 *)malloc( 64*sizeof(u8) )) == NULL )
 189         {
 190             intf_ErrMsg( "vpar error: allocation error in LoadMatrix()" );
 191             p_vpar->p_fifo->b_error = 1;
 192             return;
 193         }
 194         p_matrix->b_allocated = 1;
 195     }
 196
 197     for( i_dummy = 0; i_dummy < 64; i_dummy++ )
 198     {
 199         p_matrix->pi_matrix[p_vpar->ppi_scan[0][i_dummy]]
 200              = GetBits( &p_vpar->bit_stream, 8 );
 201     }
 202 }
 203
 204 /*****************************************************************************
 205  * LinkMatrix : Link a quantization matrix to another
 206  *****************************************************************************/
 207 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, u8 * pi_array )
 208 {
 209     if( p_matrix->b_allocated )
 210     {
 211         /* Deallocate the piece of memory. */
 212         free( p_matrix->pi_matrix );
 213         p_matrix->b_allocated = 0;
 214     }
 215
 216     p_matrix->pi_matrix = pi_array;
 217 }
 218
 219 /*
 220  * Exported functions.
 221  */
 222
 223 /*****************************************************************************
 224  * vpar_NextSequenceHeader : Find the next sequence header
 225  *****************************************************************************/
 226 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
 227 {
 228     while( !p_vpar->p_fifo->b_die )
 229     {
 230         NextStartCode( &p_vpar->bit_stream );
 231         if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
 232         {
 233             return 0;
 234         }
 235         RemoveBits( &p_vpar->bit_stream, 8 );
 236     }
 237     return 1;
 238 }
 239
 240 /*****************************************************************************
 241  * vpar_ParseHeader : Parse the next header
 242  *****************************************************************************/
 243 int vpar_ParseHeader( vpar_thread_t * p_vpar )
 244 {
 245     while( !p_vpar->p_fifo->b_die )
 246     {
 247         NextStartCode( &p_vpar->bit_stream );
 248         switch( GetBits32( &p_vpar->bit_stream ) )
 249         {
 250         case SEQUENCE_HEADER_CODE:
 251 #ifdef STATS
 252             p_vpar->c_sequences++;
 253 #endif
 254             SequenceHeader( p_vpar );
 255             return 0;
 256             break;
 257
 258         case GROUP_START_CODE:
 259             GroupHeader( p_vpar );
 260             return 0;
 261             break;
 262
 263         case PICTURE_START_CODE:
 264             PictureHeader( p_vpar );
 265             return 0;
 266             break;
 267
 268         case SEQUENCE_END_CODE:
 269             intf_DbgMsg("vpar debug: sequence end code received");
 270             return 1;
 271             break;
 272
 273         default:
 274             break;
 275         }
 276     }
 277
 278     return 0;
 279 }
 280
 281 /*
 282  * Following functions are local
 283  */
 284
 285 /*****************************************************************************
 286  * SequenceHeader : Parse the next sequence header
 287  *****************************************************************************/
 288 static void SequenceHeader( vpar_thread_t * p_vpar )
 289 {
 290 #define RESERVED    -1
 291     static int i_frame_rate_table[16] =
 292     {
 293         0,
 294         23 * 1000,
 295         24 * 1001,
 296         25 * 1001,
 297         30 * 1000,
 298         30 * 1001,
 299         50 * 1001,
 300         60 * 1000,
 301         60 * 1001,
 302         RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
 303     };
 304 #undef RESERVED
 305
 306     int i_height_save, i_width_save;
 307
 308     i_height_save = p_vpar->sequence.i_height;
 309     i_width_save = p_vpar->sequence.i_width;
 310
 311     p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
 312     p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
 313     p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
 314     p_vpar->sequence.i_frame_rate =
 315             i_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
 316
 317     /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
 318      * constrained_parameters_flag */
 319     RemoveBits( &p_vpar->bit_stream, 30 );
 320
 321     /*
 322      * Quantization matrices
 323      */
 324     if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
 325     {
 326         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 327     }
 328     else
 329     {
 330         /* Use default matrix. */
 331         LinkMatrix( &p_vpar->sequence.intra_quant,
 332                     p_vpar->pi_default_intra_quant );
 333     }
 334
 335     if( GetBits(&p_vpar->bit_stream, 1) ) /* load_non_intra_quantizer_matrix */
 336     {
 337         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 338     }
 339     else
 340     {
 341         /* Use default matrix. */
 342         LinkMatrix( &p_vpar->sequence.nonintra_quant,
 343                     p_vpar->pi_default_nonintra_quant );
 344     }
 345
 346     /* Unless later overwritten by a matrix extension, we have the same
 347      * matrices for luminance and chrominance. */
 348     LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 349                 p_vpar->sequence.intra_quant.pi_matrix );
 350     LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 351                 p_vpar->sequence.nonintra_quant.pi_matrix );
 352
 353     /*
 354      * Sequence Extension
 355      */
 356     NextStartCode( &p_vpar->bit_stream );
 357     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
 358     {
 359         int                         i_dummy;
 360
 361         /* Turn the MPEG2 flag on */
 362         p_vpar->sequence.b_mpeg2 = 1;
 363
 364         /* Parse sequence_extension */
 365         RemoveBits32( &p_vpar->bit_stream );
 366         /* extension_start_code_identifier, profile_and_level_indication */
 367         RemoveBits( &p_vpar->bit_stream, 12 );
 368         p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
 369         p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
 370         p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
 371         p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
 372         /* bit_rate_extension, marker_bit, vbv_buffer_size_extension,
 373          * low_delay */
 374         RemoveBits( &p_vpar->bit_stream, 22 );
 375         /* frame_rate_extension_n */
 376         i_dummy = GetBits( &p_vpar->bit_stream, 2 );
 377         /* frame_rate_extension_d */
 378         p_vpar->sequence.i_frame_rate *= (i_dummy + 1)
 379                                   / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
 380     }
 381     else
 382     {
 383         /* It's an MPEG-1 stream. Put adequate parameters. */
 384
 385         p_vpar->sequence.b_mpeg2 = 0;
 386         p_vpar->sequence.b_progressive = 1;
 387         p_vpar->sequence.i_chroma_format = CHROMA_420;
 388     }
 389
 390     /* Update sizes */
 391     p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
 392     p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
 393                                    (p_vpar->sequence.i_height + 15) / 16 :
 394                                    2 * ((p_vpar->sequence.i_height + 31) / 32);
 395     p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
 396                                         * p_vpar->sequence.i_mb_height;
 397     p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
 398     p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
 399     p_vpar->sequence.i_size = p_vpar->sequence.i_width
 400                                         * p_vpar->sequence.i_height;
 401
 402 #if 0
 403     if(    p_vpar->sequence.i_width != i_width_save
 404         || p_vpar->sequence.i_height != i_height_save )
 405     {
 406          /* FIXME: Warn the video output */
 407     }
 408 #endif
 409
 410     /* Extension and User data */
 411     ExtensionAndUserData( p_vpar );
 412
 413     /* XXX: The vout request and fifo opening will eventually be here */
 414
 415     /* Spawn a video output if there is none */
 416     vlc_mutex_lock( &p_vout_bank->lock );
 417
 418     if( p_vout_bank->i_count == 0 )
 419     {
 420         intf_WarnMsg( 1, "vpar: no vout present, spawning one" );
 421
 422         p_vpar->p_vout = vout_CreateThread( NULL );
 423
 424         /* Everything failed */
 425         if( p_vpar->p_vout == NULL )
 426         {
 427             intf_ErrMsg( "vpar error: can't open vout, aborting" );
 428             vlc_mutex_unlock( &p_vout_bank->lock );
 429
 430             /* XXX ! XXX ! XXX ! what to do here ? */
 431             return;
 432         }
 433
 434         p_vout_bank->pp_vout[ p_vout_bank->i_count ] = p_vpar->p_vout;
 435         p_vout_bank->i_count++;
 436     }
 437     else
 438     {
 439         /* Take the first video output FIXME: take the best one */
 440         p_vpar->p_vout = p_vout_bank->pp_vout[ 0 ];
 441     }
 442
 443     vlc_mutex_unlock( &p_vout_bank->lock );
 444 }
 445
 446 /*****************************************************************************
 447  * GroupHeader : Parse the next group of pictures header
 448  *****************************************************************************/
 449 static void GroupHeader( vpar_thread_t * p_vpar )
 450 {
 451     /* Nothing to do, we don't care. */
 452     RemoveBits( &p_vpar->bit_stream, 27 );
 453     ExtensionAndUserData( p_vpar );
 454 }
 455
 456 /*****************************************************************************
 457  * PictureHeader : Parse the next picture header
 458  *****************************************************************************/
 459 static void PictureHeader( vpar_thread_t * p_vpar )
 460 {
 461     int                 i_structure, i_previous_coding_type;
 462     boolean_t           b_parsable = 0;
 463
 464     /* Recover in case of stream discontinuity. */
 465     if( p_vpar->sequence.b_expect_discontinuity )
 466     {
 467         ReferenceUpdate( p_vpar, I_CODING_TYPE, NULL );
 468         ReferenceUpdate( p_vpar, I_CODING_TYPE, NULL );
 469         if( p_vpar->picture.p_picture != NULL )
 470         {
 471             vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
 472             p_vpar->picture.p_picture = NULL;
 473         }
 474         p_vpar->picture.i_current_structure = 0;
 475         p_vpar->sequence.b_expect_discontinuity = 0;
 476     }
 477
 478     /* Parse the picture header. */
 479     RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
 480     i_previous_coding_type = p_vpar->picture.i_coding_type;
 481     p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
 482     RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
 483
 484     if( p_vpar->picture.i_coding_type == P_CODING_TYPE
 485         || p_vpar->picture.i_coding_type == B_CODING_TYPE )
 486     {
 487         p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 1 );
 488         p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 3 )
 489                                             - 1;
 490     }
 491     if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
 492     {
 493         p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 1 );
 494         p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 3 )
 495                                             - 1;
 496     }
 497
 498     /* extra_information_picture */
 499     while( GetBits( &p_vpar->bit_stream, 1 ) )
 500     {
 501         RemoveBits( &p_vpar->bit_stream, 8 );
 502     }
 503
 504     /*
 505      * Picture Coding Extension
 506      */
 507     NextStartCode( &p_vpar->bit_stream );
 508     if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
 509     {
 510         /* Parse picture_coding_extension */
 511         RemoveBits32( &p_vpar->bit_stream );
 512         /* extension_start_code_identifier */
 513         RemoveBits( &p_vpar->bit_stream, 4 );
 514
 515         /* Pre-substract 1 for later use in MotionDelta(). */
 516         p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 ) -1;
 517         p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 ) -1;
 518         p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 ) -1;
 519         p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 ) -1;
 520         p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
 521         i_structure = GetBits( &p_vpar->bit_stream, 2 );
 522         p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
 523         p_vpar->picture.b_frame_pred_frame_dct
 524              = GetBits( &p_vpar->bit_stream, 1 );
 525         p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
 526         p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
 527         p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
 528         /* Alternate scan */
 529         p_vpar->picture.pi_scan =
 530             p_vpar->ppi_scan[ GetBits( &p_vpar->bit_stream, 1 ) ];
 531         p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
 532         /* chroma_420_type (obsolete) */
 533         RemoveBits( &p_vpar->bit_stream, 1 );
 534         p_vpar->picture.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
 535
 536         /* composite_display_flag */
 537         if( GetBits( &p_vpar->bit_stream, 1 ) )
 538         {
 539             /* v_axis, field_sequence, sub_carrier, burst_amplitude,
 540              * sub_carrier_phase */
 541             RemoveBits( &p_vpar->bit_stream, 20 );
 542         }
 543     }
 544     else
 545     {
 546         /* MPEG-1 compatibility flags */
 547         p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
 548         i_structure = FRAME_STRUCTURE;
 549         p_vpar->picture.b_top_field_first = 0;
 550         p_vpar->picture.b_frame_pred_frame_dct = 1;
 551         p_vpar->picture.b_concealment_mv = 0;
 552         p_vpar->picture.b_q_scale_type = 0;
 553         p_vpar->picture.b_intra_vlc_format = 0;
 554         p_vpar->picture.pi_scan = p_vpar->ppi_scan[0];
 555         p_vpar->picture.b_repeat_first_field = 0;
 556         p_vpar->picture.b_progressive = 1;
 557     }
 558
 559     /* Extension and User data. */
 560     ExtensionAndUserData( p_vpar );
 561
 562 #ifdef STATS
 563     p_vpar->pc_pictures[p_vpar->picture.i_coding_type]++;
 564 #endif
 565
 566     if( p_vpar->picture.i_current_structure )
 567     {
 568         if ( (i_structure == FRAME_STRUCTURE ||
 569               i_structure == p_vpar->picture.i_current_structure) )
 570         {
 571             /* We don't have the second field of the buffered frame. */
 572             if( p_vpar->picture.p_picture != NULL )
 573             {
 574                 ReferenceReplace( p_vpar,
 575                                   p_vpar->picture.i_coding_type,
 576                                   NULL );
 577                 vout_DestroyPicture( p_vpar->p_vout,
 578                                      p_vpar->picture.p_picture );
 579                 p_vpar->picture.p_picture = NULL;
 580             }
 581
 582             p_vpar->picture.i_current_structure = 0;
 583
 584             intf_WarnMsg( 2, "Odd number of field pictures." );
 585         }
 586         else
 587         {
 588             /* Second field of a frame. We will decode it if, and only if we
 589              * have decoded the first field. */
 590             if( p_vpar->picture.p_picture == NULL )
 591             {
 592                 if( (p_vpar->picture.i_coding_type == I_CODING_TYPE
 593                       && p_vpar->sequence.p_backward == NULL) )
 594                 {
 595                     /* Exceptionnally, parse the picture if it is I. We need
 596                      * this in case of an odd number of field pictures, if the
 597                      * previous picture is not intra, we desperately need a
 598                      * new reference picture. OK, this is kind of kludgy. */
 599                     p_vpar->picture.i_current_structure = 0;
 600                 }
 601                 else
 602                 {
 603                     b_parsable = 0;
 604                 }
 605             }
 606             else
 607             {
 608                 /* We suppose we have the reference pictures, since we already
 609                  * decoded the first field and the second field will not need
 610                  * any extra reference picture. There is a special case of
 611                  * P field being the second field of an I field, but ISO/IEC
 612                  * 13818-2 section 7.6.3.5 specifies that this P field will
 613                  * not need any reference picture besides the I field. So far
 614                  * so good. */
 615                 b_parsable = 1;
 616
 617                 if( p_vpar->picture.i_coding_type == P_CODING_TYPE &&
 618                     i_previous_coding_type == I_CODING_TYPE &&
 619                     p_vpar->sequence.p_forward == NULL )
 620                 {
 621                     /* This is the special case of section 7.6.3.5. Create
 622                      * a fake reference picture (which will not be used)
 623                      * but will prevent us from segfaulting in the slice
 624                      * parsing. */
 625                     static picture_t    fake_picture;
 626                     fake_picture.p_data = NULL; /* We will use it later */
 627                     p_vpar->sequence.p_forward = &fake_picture;
 628                 }
 629             }
 630         }
 631     }
 632
 633     if( !p_vpar->picture.i_current_structure )
 634     {
 635         /* First field of a frame, or new frame picture. */
 636         int     i_repeat_field;
 637
 638         /* Do we have the reference pictures ? */
 639         b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE ||
 640                          p_vpar->picture.b_concealment_mv) &&
 641                         (p_vpar->sequence.p_backward == NULL)) ||
 642                          /* p_backward will become p_forward later */
 643                        ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
 644                         (p_vpar->sequence.p_forward == NULL ||
 645                          p_vpar->sequence.p_backward == NULL)));
 646
 647         /* Compute the number of times the frame will be emitted by the
 648          * decoder (number of half-periods). */
 649         if( p_vpar->sequence.b_progressive )
 650         {
 651             i_repeat_field = (1 + p_vpar->picture.b_repeat_first_field
 652                                 + p_vpar->picture.b_top_field_first) * 2;
 653         }
 654         else
 655         {
 656             if( p_vpar->picture.b_progressive )
 657             {
 658                 i_repeat_field = 2 + p_vpar->picture.b_repeat_first_field;
 659             }
 660             else
 661             {
 662                 i_repeat_field = 2;
 663             }
 664         }
 665
 666         /* Warn synchro we have a new picture (updates pictures index). */
 667         vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type,
 668                                 i_repeat_field );
 669
 670         if( b_parsable )
 671         {
 672             /* Does synchro say we have enough time to decode it ? */
 673             b_parsable = vpar_SynchroChoose( p_vpar,
 674                                p_vpar->picture.i_coding_type, i_structure );
 675         }
 676     }
 677
 678     if( !b_parsable )
 679     {
 680         /* Update the reference pointers. */
 681         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
 682
 683         /* Update context. */
 684         if( i_structure != FRAME_STRUCTURE )
 685         {
 686             if( (p_vpar->picture.i_current_structure | i_structure)
 687                     == FRAME_STRUCTURE )
 688             {
 689                 /* The frame is complete. */
 690                 p_vpar->picture.i_current_structure = 0;
 691
 692                 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 693             }
 694             else
 695             {
 696                 p_vpar->picture.i_current_structure = i_structure;
 697             }
 698         }
 699         else
 700         {
 701             /* Warn Synchro we have trashed a picture. */
 702             vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 703         }
 704         p_vpar->picture.p_picture = NULL;
 705
 706         return;
 707     }
 708
 709     /* OK, now we are sure we will decode the picture. */
 710 #ifdef STATS
 711     p_vpar->pc_decoded_pictures[p_vpar->picture.i_coding_type]++;
 712 #endif
 713
 714 #define P_picture p_vpar->picture.p_picture
 715     p_vpar->picture.b_error = 0;
 716     p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
 717
 718     if( !p_vpar->picture.i_current_structure )
 719     {
 720         /* This is a new frame. Get a structure from the video_output. */
 721         while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
 722                               /* XXX */ 99+p_vpar->sequence.i_chroma_format,
 723                                         p_vpar->sequence.i_width,
 724                                         p_vpar->sequence.i_height ) )
 725              == NULL )
 726         {
 727             intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying");
 728             if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
 729             {
 730                 return;
 731             }
 732             msleep( VPAR_OUTMEM_SLEEP );
 733         }
 734
 735         /* Initialize values. */
 736         vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
 737         P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
 738         P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
 739         p_vpar->picture.i_field_width = ( p_vpar->sequence.i_width
 740                     << ( 1 - p_vpar->picture.b_frame_structure ) );
 741
 742 /* FIXME ! remove asap ?? */
 743 //memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
 744
 745         /* Update the reference pointers. */
 746         ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
 747     }
 748
 749     /* Initialize picture data for decoding. */
 750     p_vpar->picture.i_current_structure |= i_structure;
 751     p_vpar->picture.i_structure = i_structure;
 752     p_vpar->picture.b_second_field =
 753         (i_structure != p_vpar->picture.i_current_structure);
 754     p_vpar->picture.b_current_field =
 755         (i_structure == BOTTOM_FIELD );
 756
 757     if( p_vpar->sequence.b_mpeg2 )
 758     {
 759         static f_picture_data_t ppf_picture_data[4][4] =
 760         {
 761             {
 762                 NULL, NULL, NULL, NULL
 763             },
 764             {
 765                 /* TOP_FIELD */
 766 #if (VPAR_OPTIM_LEVEL > 1)
 767                 NULL, vpar_PictureData2IT, vpar_PictureData2PT,
 768                 vpar_PictureData2BT
 769 #else
 770                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
 771                 vpar_PictureDataGENERIC
 772 #endif
 773             },
 774             {
 775                 /* BOTTOM_FIELD */
 776 #if (VPAR_OPTIM_LEVEL > 1)
 777                 NULL, vpar_PictureData2IB, vpar_PictureData2PB,
 778                 vpar_PictureData2BB
 779 #else
 780                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
 781                 vpar_PictureDataGENERIC
 782 #endif
 783             },
 784             {
 785                 /* FRAME_PICTURE */
 786 #if (VPAR_OPTIM_LEVEL > 0)
 787                 NULL, vpar_PictureData2IF, vpar_PictureData2PF,
 788                 vpar_PictureData2BF
 789 #else
 790                 NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
 791                 vpar_PictureDataGENERIC
 792 #endif
 793             }
 794         };
 795
 796         ppf_picture_data[p_vpar->picture.i_structure]
 797                         [p_vpar->picture.i_coding_type]( p_vpar );
 798     }
 799     else
 800     {
 801 #if (VPAR_OPTIM_LEVEL > 0)
 802         static f_picture_data_t pf_picture_data[5] =
 803         { NULL, vpar_PictureData1I, vpar_PictureData1P, vpar_PictureData1B,
 804           vpar_PictureData1D };
 805
 806         pf_picture_data[p_vpar->picture.i_coding_type]( p_vpar );
 807 #else
 808         vpar_PictureDataGENERIC( p_vpar );
 809 #endif
 810     }
 811
 812     /* Wait for all the macroblocks to be decoded. */
 813     p_vpar->pool.pf_wait_pool( &p_vpar->pool );
 814
 815     /* Re-spawn decoder threads if the user changed settings. */
 816     vpar_SpawnPool( p_vpar );
 817
 818     if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
 819     {
 820         return;
 821     }
 822
 823     if( p_vpar->sequence.p_forward != NULL &&
 824         p_vpar->sequence.p_forward->p_data == NULL )
 825     {
 826         /* This can only happen with the fake picture created for section
 827          * 7.6.3.5. Clean up our mess. */
 828         p_vpar->sequence.p_forward = NULL;
 829     }
 830
 831     if( p_vpar->picture.b_error )
 832     {
 833         /* Trash picture. */
 834 #ifdef STATS
 835         p_vpar->pc_malformed_pictures[p_vpar->picture.i_coding_type]++;
 836 #endif
 837
 838         vpar_SynchroEnd( p_vpar, p_vpar->picture.i_coding_type,
 839                          p_vpar->picture.i_structure, 1 );
 840         vout_DestroyPicture( p_vpar->p_vout, P_picture );
 841
 842         ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
 843
 844         /* Prepare context for the next picture. */
 845         P_picture = NULL;
 846         if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 847             p_vpar->picture.i_current_structure = 0;
 848     }
 849     else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
 850     {
 851         /* Frame completely parsed. */
 852         vpar_SynchroEnd( p_vpar, p_vpar->picture.i_coding_type,
 853                          p_vpar->picture.i_structure, 0 );
 854         vout_DisplayPicture( p_vpar->p_vout, P_picture );
 855
 856         /* Prepare context for the next picture. */
 857         P_picture = NULL;
 858         p_vpar->picture.i_current_structure = 0;
 859     }
 860 #undef P_picture
 861 }
 862
 863 /*****************************************************************************
 864  * ExtensionAndUserData : Parse the extension_and_user_data structure
 865  *****************************************************************************/
 866 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
 867 {
 868     while( !p_vpar->p_fifo->b_die )
 869     {
 870         NextStartCode( &p_vpar->bit_stream );
 871         switch( ShowBits( &p_vpar->bit_stream, 32 ) )
 872         {
 873         case EXTENSION_START_CODE:
 874             RemoveBits32( &p_vpar->bit_stream );
 875             switch( GetBits( &p_vpar->bit_stream, 4 ) )
 876             {
 877             case SEQUENCE_DISPLAY_EXTENSION_ID:
 878                 SequenceDisplayExtension( p_vpar );
 879                 break;
 880             case QUANT_MATRIX_EXTENSION_ID:
 881                 QuantMatrixExtension( p_vpar );
 882                 break;
 883             case SEQUENCE_SCALABLE_EXTENSION_ID:
 884                 SequenceScalableExtension( p_vpar );
 885                 break;
 886             case PICTURE_DISPLAY_EXTENSION_ID:
 887                 PictureDisplayExtension( p_vpar );
 888                 break;
 889             case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
 890                 PictureSpatialScalableExtension( p_vpar );
 891                 break;
 892             case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
 893                 PictureTemporalScalableExtension( p_vpar );
 894                 break;
 895             case COPYRIGHT_EXTENSION_ID:
 896                 CopyrightExtension( p_vpar );
 897                 break;
 898             default:
 899                 break;
 900             }
 901             break;
 902
 903         case USER_DATA_START_CODE:
 904             RemoveBits32( &p_vpar->bit_stream );
 905             /* Wait for the next start code */
 906             break;
 907
 908         default:
 909             return;
 910         }
 911     }
 912 }
 913
 914
 915 /*****************************************************************************
 916  * SequenceDisplayExtension : Parse the sequence_display_extension structure *
 917  *****************************************************************************/
 918
 919 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
 920 {
 921     /* We don't care sequence_display_extension. */
 922     /* video_format */
 923     RemoveBits( &p_vpar->bit_stream, 3 );
 924     if( GetBits( &p_vpar->bit_stream, 1 ) )
 925     {
 926         /* Two bytes for color_desciption */
 927         RemoveBits( &p_vpar->bit_stream, 16 );
 928         p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
 929     }
 930     /* display_horizontal and vertical_size and a marker_bit */
 931     RemoveBits( &p_vpar->bit_stream, 29 );
 932 }
 933
 934
 935 /*****************************************************************************
 936  * QuantMatrixExtension : Load quantization matrices for luminance           *
 937  *                        and chrominance                                    *
 938  *****************************************************************************/
 939
 940 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
 941 {
 942     if( GetBits( &p_vpar->bit_stream, 1 ) )
 943     {
 944         /* Load intra_quantiser_matrix for luminance. */
 945         LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
 946     }
 947     else
 948     {
 949         /* Use the default matrix. */
 950         LinkMatrix( &p_vpar->sequence.intra_quant,
 951                     p_vpar->pi_default_intra_quant );
 952     }
 953     if( GetBits( &p_vpar->bit_stream, 1 ) )
 954     {
 955         /* Load non_intra_quantiser_matrix for luminance. */
 956         LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
 957     }
 958     else
 959     {
 960         /* Use the default matrix. */
 961         LinkMatrix( &p_vpar->sequence.nonintra_quant,
 962                     p_vpar->pi_default_nonintra_quant );
 963     }
 964     if( GetBits( &p_vpar->bit_stream, 1 ) )
 965     {
 966         /* Load intra_quantiser_matrix for chrominance. */
 967         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
 968     }
 969     else
 970     {
 971         /* Link the chrominance intra matrix to the luminance one. */
 972         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 973                     p_vpar->sequence.intra_quant.pi_matrix );
 974     }
 975     if( GetBits( &p_vpar->bit_stream, 1 ) )
 976     {
 977         /* Load non_intra_quantiser_matrix for chrominance. */
 978         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 979     }
 980     else
 981     {
 982         /* Link the chrominance intra matrix to the luminance one. */
 983         LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
 984                     p_vpar->sequence.intra_quant.pi_matrix );
 985     }
 986     if( GetBits( &p_vpar->bit_stream, 1 ) )
 987     {
 988         /* Load non_intra_quantiser_matrix for chrominance. */
 989         LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
 990     }
 991     else
 992     {
 993         /* Link the chrominance nonintra matrix to the luminance one. */
 994         LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
 995                     p_vpar->sequence.nonintra_quant.pi_matrix );
 996     }
 997 }
 998
 999
1000 /*****************************************************************************
1001  * SequenceScalableExtension : Parse the sequence_scalable_extension         *
1002  *                             structure to handle scalable coding           *
1003  *****************************************************************************/
1004
1005 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
1006 {
1007     /* We don't care about anything scalable except the scalable mode. */
1008     switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
1009     /* The length of the structure depends on the value of the scalable_mode */
1010     {
1011         case 1:
1012             RemoveBits32( &p_vpar->bit_stream );
1013             RemoveBits( &p_vpar->bit_stream, 21 );
1014             break;
1015         case 2:
1016             RemoveBits( &p_vpar->bit_stream, 12 );
1017             break;
1018         default:
1019             RemoveBits( &p_vpar->bit_stream, 4 );
1020     }
1021
1022 }
1023 /*****************************************************************************
1024  * PictureDisplayExtension : Parse the picture_display_extension structure   *
1025  *****************************************************************************/
1026
1027 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
1028 {
1029     /* Number of frame center offset */
1030     int i_nb, i_dummy;
1031     /* I am not sure it works but it should
1032         (fewer tests than shown in §6.3.12) */
1033     i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
1034                                             p_vpar->picture.b_repeat_first_field +
1035                                             p_vpar->picture.b_top_field_first
1036                            : ( p_vpar->picture.b_frame_structure + 1 ) +
1037                              p_vpar->picture.b_repeat_first_field;
1038     for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
1039     {
1040         RemoveBits( &p_vpar->bit_stream, 17 );
1041         RemoveBits( &p_vpar->bit_stream, 17 );
1042     }
1043 }
1044
1045
1046 /*****************************************************************************
1047  * PictureSpatialScalableExtension                                           *
1048  *****************************************************************************/
1049
1050 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1051 {
1052     /* That's scalable, so we trash it */
1053     RemoveBits32( &p_vpar->bit_stream );
1054     RemoveBits( &p_vpar->bit_stream, 16 );
1055 }
1056
1057
1058 /*****************************************************************************
1059  * PictureTemporalScalableExtension                                          *
1060  *****************************************************************************/
1061
1062 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1063 {
1064     /* Scalable again, trashed again */
1065     RemoveBits( &p_vpar->bit_stream, 23 );
1066 }
1067
1068
1069 /*****************************************************************************
1070  * CopyrightExtension : Keeps some legal informations                        *
1071  *****************************************************************************/
1072
1073 static void CopyrightExtension( vpar_thread_t * p_vpar )
1074 {
1075     u32     i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1076     p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1077         /* A flag that says whether the copyright information is significant */
1078     p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1079         /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1080     p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1081         /* Reserved bits */
1082     RemoveBits( &p_vpar->bit_stream, 8 );
1083         /* The copyright_number is split in three parts */
1084         /* first part */
1085     i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1086     RemoveBits( &p_vpar->bit_stream, 1 );
1087         /* second part */
1088     i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1089     RemoveBits( &p_vpar->bit_stream, 1 );
1090         /* third part and sum */
1091     p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1092                                       ( (u64)i_copyright_nb_2 << 22 ) |
1093                                       ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );
1094 }