1 /*****************************************************************************
2 * vpar_headers.c : headers parsing
3 *****************************************************************************
4 * Copyright (C) 1999, 2000 VideoLAN
5 * $Id: vpar_headers.c,v 1.73 2001/01/17 18:17:31 massiot Exp $
7 * Authors: Christophe Massiot <massiot@via.ecp.fr>
8 * Stéphane Borel <stef@via.ecp.fr>
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.
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.
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 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
30 #include <stdlib.h> /* free() */
40 #include "stream_control.h"
41 #include "input_ext-dec.h"
44 #include "video_output.h"
46 #include "video_decoder.h"
47 #include "../video_decoder/vdec_idct.h"
48 #include "../video_decoder/vdec_motion.h"
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"
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 );
76 /*****************************************************************************
77 * pi_default_intra_quant : default quantization matrix
78 *****************************************************************************/
79 u8 pi_default_intra_quant[] =
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
91 /*****************************************************************************
92 * pi_default_nonintra_quant : default quantization matrix
93 *****************************************************************************/
94 u8 pi_default_nonintra_quant[] =
96 16, 16, 16, 16, 16, 16, 16, 16,
97 16, 16, 16, 16, 16, 16, 16, 16,
98 16, 16, 16, 16, 16, 16, 16, 16,
99 16, 16, 16, 16, 16, 16, 16, 16,
100 16, 16, 16, 16, 16, 16, 16, 16,
101 16, 16, 16, 16, 16, 16, 16, 16,
102 16, 16, 16, 16, 16, 16, 16, 16,
103 16, 16, 16, 16, 16, 16, 16, 16
106 /*****************************************************************************
107 * pi_scan : zig-zag and alternate scan patterns
108 *****************************************************************************/
111 { /* Zig-Zag pattern */
112 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
113 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
114 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
115 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
117 { /* Alternate scan pattern */
118 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
119 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
120 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
121 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
126 * Local inline functions.
129 /*****************************************************************************
130 * ReferenceUpdate : Update the reference pointers when we have a new picture
131 *****************************************************************************/
132 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
134 picture_t * p_newref )
136 if( i_coding_type != B_CODING_TYPE )
138 if( p_vpar->sequence.p_forward != NULL )
140 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
142 if( p_vpar->sequence.p_backward != NULL )
144 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
145 vpar_SynchroDate( p_vpar ) );
147 p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
148 p_vpar->sequence.p_backward = p_newref;
149 if( p_newref != NULL )
151 vout_LinkPicture( p_vpar->p_vout, p_newref );
154 else if( p_newref != NULL )
156 /* Put date immediately. */
157 vout_DatePicture( p_vpar->p_vout, p_newref, vpar_SynchroDate(p_vpar) );
161 /*****************************************************************************
162 * ReferenceReplace : Replace the last reference pointer when we destroy
164 *****************************************************************************/
165 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
167 picture_t * p_newref )
169 if( i_coding_type != B_CODING_TYPE )
171 if( p_vpar->sequence.p_backward != NULL )
173 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
175 p_vpar->sequence.p_backward = p_newref;
176 if( p_newref != NULL )
178 vout_LinkPicture( p_vpar->p_vout, p_newref );
183 /*****************************************************************************
184 * LoadMatrix : Load a quantization matrix
185 *****************************************************************************/
186 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar,
187 quant_matrix_t * p_matrix )
191 if( !p_matrix->b_allocated )
193 /* Allocate a piece of memory to load the matrix. */
194 if( (p_matrix->pi_matrix = (u8 *)malloc( 64*sizeof(u8) )) == NULL )
196 intf_ErrMsg( "vpar error: allocation error in LoadMatrix()" );
197 p_vpar->p_fifo->b_error = 1;
200 p_matrix->b_allocated = 1;
203 for( i_dummy = 0; i_dummy < 64; i_dummy++ )
205 p_matrix->pi_matrix[p_vpar->ppi_scan[SCAN_ZIGZAG][i_dummy]]
206 = GetBits( &p_vpar->bit_stream, 8 );
210 /* Discrete Fourier Transform requires the quantization matrices to
211 * be normalized before using them. */
212 vdec_NormQuantMatrix( p_matrix->pi_matrix );
216 /*****************************************************************************
217 * LinkMatrix : Link a quantization matrix to another
218 *****************************************************************************/
219 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, u8 * pi_array )
221 if( p_matrix->b_allocated )
223 /* Deallocate the piece of memory. */
224 free( p_matrix->pi_matrix );
225 p_matrix->b_allocated = 0;
228 p_matrix->pi_matrix = pi_array;
232 * Exported functions.
235 /*****************************************************************************
236 * vpar_NextSequenceHeader : Find the next sequence header
237 *****************************************************************************/
238 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
240 while( !p_vpar->p_fifo->b_die )
242 NextStartCode( &p_vpar->bit_stream );
243 if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
247 RemoveBits( &p_vpar->bit_stream, 8 );
252 /*****************************************************************************
253 * vpar_ParseHeader : Parse the next header
254 *****************************************************************************/
255 int vpar_ParseHeader( vpar_thread_t * p_vpar )
257 while( !p_vpar->p_fifo->b_die )
259 NextStartCode( &p_vpar->bit_stream );
260 switch( GetBits32( &p_vpar->bit_stream ) )
262 case SEQUENCE_HEADER_CODE:
264 p_vpar->c_sequences++;
266 SequenceHeader( p_vpar );
270 case GROUP_START_CODE:
271 GroupHeader( p_vpar );
275 case PICTURE_START_CODE:
276 PictureHeader( p_vpar );
280 case SEQUENCE_END_CODE:
281 intf_DbgMsg("vpar debug: sequence end code received");
293 * Following functions are local
296 /*****************************************************************************
297 * SequenceHeader : Parse the next sequence header
298 *****************************************************************************/
299 static void SequenceHeader( vpar_thread_t * p_vpar )
302 static int i_frame_rate_table[16] =
313 RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
317 int i_height_save, i_width_save;
319 i_height_save = p_vpar->sequence.i_height;
320 i_width_save = p_vpar->sequence.i_width;
322 p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
323 p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
324 p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
325 p_vpar->sequence.i_frame_rate =
326 i_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
328 /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
329 * constrained_parameters_flag */
330 RemoveBits( &p_vpar->bit_stream, 30 );
333 * Quantization matrices
335 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
337 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
341 /* Use default matrix. */
342 LinkMatrix( &p_vpar->sequence.intra_quant,
343 p_vpar->pi_default_intra_quant );
346 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
348 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
352 /* Use default matrix. */
353 LinkMatrix( &p_vpar->sequence.nonintra_quant,
354 p_vpar->pi_default_nonintra_quant );
357 /* Unless later overwritten by a matrix extension, we have the same
358 * matrices for luminance and chrominance. */
359 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
360 p_vpar->sequence.intra_quant.pi_matrix );
361 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
362 p_vpar->sequence.nonintra_quant.pi_matrix );
367 NextStartCode( &p_vpar->bit_stream );
368 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
372 /* Turn the MPEG2 flag on */
373 p_vpar->sequence.b_mpeg2 = 1;
375 /* Parse sequence_extension */
376 RemoveBits32( &p_vpar->bit_stream );
377 /* extension_start_code_identifier, profile_and_level_indication */
378 RemoveBits( &p_vpar->bit_stream, 12 );
379 p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
380 p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
381 p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
382 p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
383 /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
384 RemoveBits( &p_vpar->bit_stream, 22 );
385 /* frame_rate_extension_n */
386 i_dummy = GetBits( &p_vpar->bit_stream, 2 );
387 /* frame_rate_extension_d */
388 p_vpar->sequence.i_frame_rate *= (i_dummy + 1)
389 / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
393 /* It's an MPEG-1 stream. Put adequate parameters. */
395 p_vpar->sequence.b_mpeg2 = 0;
396 p_vpar->sequence.b_progressive = 1;
397 p_vpar->sequence.i_chroma_format = CHROMA_420;
401 p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
402 p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
403 (p_vpar->sequence.i_height + 15) / 16 :
404 2 * ((p_vpar->sequence.i_height + 31) / 32);
405 p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
406 * p_vpar->sequence.i_mb_height;
407 p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
408 p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
409 p_vpar->sequence.i_size = p_vpar->sequence.i_width
410 * p_vpar->sequence.i_height;
412 /* Update chromatic information. */
413 switch( p_vpar->sequence.i_chroma_format )
416 p_vpar->sequence.i_chroma_nb_blocks = 2;
417 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
418 p_vpar->sequence.i_chroma_mb_width = 8;
419 p_vpar->sequence.i_chroma_mb_height = 8;
423 p_vpar->sequence.i_chroma_nb_blocks = 4;
424 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
425 p_vpar->sequence.i_chroma_mb_width = 8;
426 p_vpar->sequence.i_chroma_mb_height = 16;
430 p_vpar->sequence.i_chroma_nb_blocks = 8;
431 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
432 p_vpar->sequence.i_chroma_mb_width = 16;
433 p_vpar->sequence.i_chroma_mb_height = 16;
436 /* Reset scalable_mode. */
437 p_vpar->sequence.i_scalable_mode = SC_NONE;
440 if( p_vpar->sequence.i_width != i_width_save
441 || p_vpar->sequence.i_height != i_height_save )
443 /* FIXME: What do we do in case of a size change ?? */
447 /* Extension and User data */
448 ExtensionAndUserData( p_vpar );
451 /*****************************************************************************
452 * GroupHeader : Parse the next group of pictures header
453 *****************************************************************************/
454 static void GroupHeader( vpar_thread_t * p_vpar )
456 /* Nothing to do, we don't care. */
457 RemoveBits( &p_vpar->bit_stream, 27 );
458 ExtensionAndUserData( p_vpar );
461 /*****************************************************************************
462 * PictureHeader : Parse the next picture header
463 *****************************************************************************/
464 static void PictureHeader( vpar_thread_t * p_vpar )
468 boolean_t b_parsable;
473 RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
474 p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
475 RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
477 if( p_vpar->picture.i_coding_type == P_CODING_TYPE
478 || p_vpar->picture.i_coding_type == B_CODING_TYPE )
480 p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
481 p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
483 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
485 p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
486 p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
489 /* extra_information_picture */
490 while( GetBits( &p_vpar->bit_stream, 1 ) )
492 RemoveBits( &p_vpar->bit_stream, 8 );
496 * Picture Coding Extension
498 NextStartCode( &p_vpar->bit_stream );
499 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
501 /* Parse picture_coding_extension */
502 RemoveBits32( &p_vpar->bit_stream );
503 /* extension_start_code_identifier */
504 RemoveBits( &p_vpar->bit_stream, 4 );
506 p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
507 p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
508 p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
509 p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
510 p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
511 i_structure = GetBits( &p_vpar->bit_stream, 2 );
512 p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
513 p_vpar->picture.b_frame_pred_frame_dct
514 = GetBits( &p_vpar->bit_stream, 1 );
515 p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
516 p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
517 p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
518 p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
519 p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
520 /* chroma_420_type (obsolete) */
521 RemoveBits( &p_vpar->bit_stream, 1 );
522 p_vpar->picture.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
524 /* composite_display_flag */
525 if( GetBits( &p_vpar->bit_stream, 1 ) )
527 /* v_axis, field_sequence, sub_carrier, burst_amplitude,
528 * sub_carrier_phase */
529 RemoveBits( &p_vpar->bit_stream, 20 );
534 /* MPEG-1 compatibility flags */
535 p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
536 i_structure = FRAME_STRUCTURE;
537 p_vpar->picture.b_top_field_first = 0;
538 p_vpar->picture.b_frame_pred_frame_dct = 1;
539 p_vpar->picture.b_concealment_mv = 0;
540 p_vpar->picture.b_q_scale_type = 0;
541 p_vpar->picture.b_intra_vlc_format = 0;
542 p_vpar->picture.b_alternate_scan = 0; /* zigzag */
543 p_vpar->picture.b_repeat_first_field = 1; /* FIXME! this contradicts
545 p_vpar->picture.b_progressive = 1;
549 p_vpar->pc_pictures[p_vpar->picture.i_coding_type]++;
552 if( p_vpar->picture.i_current_structure &&
553 (i_structure == FRAME_STRUCTURE ||
554 i_structure == p_vpar->picture.i_current_structure) )
556 /* We don't have the second field of the buffered frame. */
557 if( p_vpar->picture.p_picture != NULL )
559 ReferenceReplace( p_vpar,
560 p_vpar->picture.i_coding_type,
564 for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
566 vpar_DestroyMacroblock( &p_vpar->vfifo,
567 p_vpar->picture.pp_mb[i_mb] );
570 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
573 p_vpar->picture.i_current_structure = 0;
575 intf_DbgMsg("vpar debug: odd number of field picture.");
578 /* Do we have the reference pictures ? */
579 b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
580 (p_vpar->sequence.p_backward == NULL)) ||
581 /* p_backward will become p_forward later */
582 ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
583 (p_vpar->sequence.p_forward == NULL ||
584 p_vpar->sequence.p_backward == NULL)));
586 if( p_vpar->picture.i_current_structure )
588 /* Second field of a frame. We will decode it if, and only if we
589 * have decoded the first field. */
592 b_parsable = (p_vpar->picture.p_picture != NULL);
599 /* Compute the number of times the frame will be emitted by the
600 * decoder (number of periods). */
601 if( p_vpar->sequence.b_progressive )
603 i_repeat_field = 1 + p_vpar->picture.b_repeat_first_field
604 + p_vpar->picture.b_top_field_first;
608 if( p_vpar->picture.b_progressive )
610 i_repeat_field = 2 + p_vpar->picture.b_repeat_first_field;
618 /* Warn synchro we have a new picture (updates pictures index). */
619 vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type,
624 /* Does synchro say we have enough time to decode it ? */
625 b_parsable = vpar_SynchroChoose( p_vpar,
626 p_vpar->picture.i_coding_type, i_structure );
632 /* Update the reference pointers. */
633 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
635 /* Update context. */
636 if( i_structure != FRAME_STRUCTURE )
638 if( (p_vpar->picture.i_current_structure | i_structure)
641 p_vpar->picture.i_current_structure = 0;
645 /* The frame is complete. */
646 p_vpar->picture.i_current_structure = i_structure;
648 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
653 /* Warn Synchro we have trashed a picture. */
654 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
656 p_vpar->picture.p_picture = NULL;
661 /* OK, now we are sure we will decode the picture. */
663 p_vpar->pc_decoded_pictures[p_vpar->picture.i_coding_type]++;
666 #define P_picture p_vpar->picture.p_picture
667 p_vpar->picture.b_error = 0;
668 p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
670 if( !p_vpar->picture.i_current_structure )
672 /* This is a new frame. Get a structure from the video_output. */
673 while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
674 99+p_vpar->sequence.i_chroma_format, /*XXX??*/
675 p_vpar->sequence.i_width,
676 p_vpar->sequence.i_height ) )
679 intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying");
680 if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
684 msleep( VPAR_OUTMEM_SLEEP );
687 /* Initialize values. */
688 vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
689 P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
690 P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
691 p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
692 << ( 1 - p_vpar->picture.b_frame_structure ) );
693 p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
694 << ( 1 - p_vpar->picture.b_frame_structure ));
696 P_picture->i_deccount = p_vpar->sequence.i_mb_size;
698 memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
700 /* FIXME ! remove asap ?? */
701 //memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
703 /* Update the reference pointers. */
704 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
707 /* Link referenced pictures for the decoder
708 * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
709 if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
710 p_vpar->picture.i_coding_type == B_CODING_TYPE )
712 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
714 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
716 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
720 p_vpar->picture.i_current_structure |= i_structure;
721 p_vpar->picture.i_structure = i_structure;
723 /* Initialize picture data for decoding. */
724 if( i_structure == BOTTOM_FIELD )
726 i_mb_base = p_vpar->sequence.i_mb_size >> 1;
727 p_vpar->mb.i_l_y = 1;
728 p_vpar->mb.i_c_y = 1;
733 p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
735 p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
737 /* Extension and User data. */
738 ExtensionAndUserData( p_vpar );
740 vpar_PictureData( p_vpar, i_mb_base );
742 if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
747 if( p_vpar->picture.b_error )
751 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
753 vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
758 p_vpar->pc_malformed_pictures[p_vpar->picture.i_coding_type]++;
761 if( P_picture->i_deccount != 1 )
763 vpar_SynchroEnd( p_vpar, 1 );
764 vout_DestroyPicture( p_vpar->p_vout, P_picture );
767 ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
769 /* Prepare context for the next picture. */
771 if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
772 p_vpar->picture.i_current_structure = 0;
774 else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
776 /* Frame completely parsed. */
778 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
780 vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
783 /* Send signal to the video_decoder. */
784 vlc_mutex_lock( &p_vpar->vfifo.lock );
785 vlc_cond_signal( &p_vpar->vfifo.wait );
786 vlc_mutex_unlock( &p_vpar->vfifo.lock );
789 /* Prepare context for the next picture. */
791 p_vpar->picture.i_current_structure = 0;
796 /*****************************************************************************
797 * ExtensionAndUserData : Parse the extension_and_user_data structure
798 *****************************************************************************/
799 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
801 while( !p_vpar->p_fifo->b_die )
803 NextStartCode( &p_vpar->bit_stream );
804 switch( ShowBits( &p_vpar->bit_stream, 32 ) )
806 case EXTENSION_START_CODE:
807 RemoveBits32( &p_vpar->bit_stream );
808 switch( GetBits( &p_vpar->bit_stream, 4 ) )
810 case SEQUENCE_DISPLAY_EXTENSION_ID:
811 SequenceDisplayExtension( p_vpar );
813 case QUANT_MATRIX_EXTENSION_ID:
814 QuantMatrixExtension( p_vpar );
816 case SEQUENCE_SCALABLE_EXTENSION_ID:
817 SequenceScalableExtension( p_vpar );
819 case PICTURE_DISPLAY_EXTENSION_ID:
820 PictureDisplayExtension( p_vpar );
822 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
823 PictureSpatialScalableExtension( p_vpar );
825 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
826 PictureTemporalScalableExtension( p_vpar );
828 case COPYRIGHT_EXTENSION_ID:
829 CopyrightExtension( p_vpar );
835 case USER_DATA_START_CODE:
836 RemoveBits32( &p_vpar->bit_stream );
837 /* Wait for the next start code */
847 /*****************************************************************************
848 * SequenceDisplayExtension : Parse the sequence_display_extension structure *
849 *****************************************************************************/
851 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
853 /* We don't care sequence_display_extension. */
855 RemoveBits( &p_vpar->bit_stream, 3 );
856 if( GetBits( &p_vpar->bit_stream, 1 ) )
858 /* Two bytes for color_desciption */
859 RemoveBits( &p_vpar->bit_stream, 16 );
860 p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
862 /* display_horizontal and vertical_size and a marker_bit */
863 RemoveBits( &p_vpar->bit_stream, 29 );
867 /*****************************************************************************
868 * QuantMatrixExtension : Load quantization matrices for luminance *
870 *****************************************************************************/
872 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
874 if( GetBits( &p_vpar->bit_stream, 1 ) )
876 /* Load intra_quantiser_matrix for luminance. */
877 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
881 /* Use the default matrix. */
882 LinkMatrix( &p_vpar->sequence.intra_quant,
883 p_vpar->pi_default_intra_quant );
885 if( GetBits( &p_vpar->bit_stream, 1 ) )
887 /* Load non_intra_quantiser_matrix for luminance. */
888 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
892 /* Use the default matrix. */
893 LinkMatrix( &p_vpar->sequence.nonintra_quant,
894 p_vpar->pi_default_nonintra_quant );
896 if( GetBits( &p_vpar->bit_stream, 1 ) )
898 /* Load intra_quantiser_matrix for chrominance. */
899 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
903 /* Link the chrominance intra matrix to the luminance one. */
904 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
905 p_vpar->sequence.intra_quant.pi_matrix );
907 if( GetBits( &p_vpar->bit_stream, 1 ) )
909 /* Load non_intra_quantiser_matrix for chrominance. */
910 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
914 /* Link the chrominance intra matrix to the luminance one. */
915 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
916 p_vpar->sequence.intra_quant.pi_matrix );
918 if( GetBits( &p_vpar->bit_stream, 1 ) )
920 /* Load non_intra_quantiser_matrix for chrominance. */
921 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
925 /* Link the chrominance nonintra matrix to the luminance one. */
926 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
927 p_vpar->sequence.nonintra_quant.pi_matrix );
932 /*****************************************************************************
933 * SequenceScalableExtension : Parse the sequence_scalable_extension *
934 * structure to handle scalable coding *
935 *****************************************************************************/
937 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
939 /* We don't care about anything scalable except the scalable mode. */
940 switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
941 /* The length of the structure depends on the value of the scalable_mode */
944 RemoveBits32( &p_vpar->bit_stream );
945 RemoveBits( &p_vpar->bit_stream, 21 );
948 RemoveBits( &p_vpar->bit_stream, 12 );
951 RemoveBits( &p_vpar->bit_stream, 4 );
955 /*****************************************************************************
956 * PictureDisplayExtension : Parse the picture_display_extension structure *
957 *****************************************************************************/
959 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
961 /* Number of frame center offset */
963 /* I am not sure it works but it should
964 (fewer tests than shown in §6.3.12) */
965 i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
966 p_vpar->picture.b_repeat_first_field +
967 p_vpar->picture.b_top_field_first
968 : ( p_vpar->picture.b_frame_structure + 1 ) +
969 p_vpar->picture.b_repeat_first_field;
970 for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
972 RemoveBits( &p_vpar->bit_stream, 17 );
973 RemoveBits( &p_vpar->bit_stream, 17 );
978 /*****************************************************************************
979 * PictureSpatialScalableExtension *
980 *****************************************************************************/
982 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
984 /* That's scalable, so we trash it */
985 RemoveBits32( &p_vpar->bit_stream );
986 RemoveBits( &p_vpar->bit_stream, 16 );
990 /*****************************************************************************
991 * PictureTemporalScalableExtension *
992 *****************************************************************************/
994 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
996 /* Scalable again, trashed again */
997 RemoveBits( &p_vpar->bit_stream, 23 );
1001 /*****************************************************************************
1002 * CopyrightExtension : Keeps some legal informations *
1003 *****************************************************************************/
1005 static void CopyrightExtension( vpar_thread_t * p_vpar )
1007 u32 i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1008 p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1009 /* A flag that says whether the copyright information is significant */
1010 p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1011 /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1012 p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1014 RemoveBits( &p_vpar->bit_stream, 8 );
1015 /* The copyright_number is split in three parts */
1017 i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1018 RemoveBits( &p_vpar->bit_stream, 1 );
1020 i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1021 RemoveBits( &p_vpar->bit_stream, 1 );
1022 /* third part and sum */
1023 p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1024 ( (u64)i_copyright_nb_2 << 22 ) |
1025 ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );