1 /*****************************************************************************
2 * vpar_headers.c : headers parsing
3 *****************************************************************************
4 * Copyright (C) 1999, 2000 VideoLAN
5 * $Id: vpar_headers.c,v 1.71 2001/01/16 17:59:23 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 *****************************************************************************/
80 int pi_default_intra_quant[] =
82 8, 16, 19, 22, 26, 27, 29, 34,
83 16, 16, 22, 24, 27, 29, 34, 37,
84 19, 22, 26, 27, 29, 34, 34, 38,
85 22, 22, 26, 27, 29, 34, 37, 40,
86 22, 26, 27, 29, 32, 35, 40, 48,
87 26, 27, 29, 32, 35, 40, 48, 58,
88 26, 27, 29, 34, 38, 46, 56, 69,
89 27, 29, 35, 38, 46, 56, 69, 83
92 int pi_default_intra_quant[] =
94 2048, 5681, 6355, 6623, 6656, 5431, 4018, 2401,
95 5681, 7880, 10207, 10021, 9587, 8091, 6534, 3625,
96 6355, 10207, 11363, 10619, 9700, 8935, 6155, 3507,
97 6623, 9186, 10226, 9557, 8730, 8041, 6028, 3322,
98 5632, 9232, 9031, 8730, 8192, 7040, 5542, 3390,
99 5230, 7533, 7621, 7568, 7040, 6321, 5225, 3219,
100 3602, 5189, 5250, 5539, 5265, 5007, 4199, 2638,
101 1907, 2841, 3230, 3156, 3249, 3108, 2638, 1617
105 /*****************************************************************************
106 * pi_default_nonintra_quant : default quantization matrix
107 *****************************************************************************/
109 int pi_default_nonintra_quant[] =
111 16, 16, 16, 16, 16, 16, 16, 16,
112 16, 16, 16, 16, 16, 16, 16, 16,
113 16, 16, 16, 16, 16, 16, 16, 16,
114 16, 16, 16, 16, 16, 16, 16, 16,
115 16, 16, 16, 16, 16, 16, 16, 16,
116 16, 16, 16, 16, 16, 16, 16, 16,
117 16, 16, 16, 16, 16, 16, 16, 16,
118 16, 16, 16, 16, 16, 16, 16, 16
121 int pi_default_nonintra_quanit[] =
123 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
124 5680, 7888, 7424, 6688, 5680, 4464, 3072, 1568,
125 5344, 7424, 6992, 6288, 5344, 4208, 2896, 1472,
126 4816, 6688, 6288, 5664, 4816, 3792, 2608, 1328,
127 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
128 3216, 4464, 4208, 3792, 3216, 2528, 1744, 880,
129 2224, 3072, 2896, 2608, 2224, 1744, 1200, 608,
130 1136, 1568, 1472, 1328, 1136, 880, 608, 304
134 /*****************************************************************************
135 * pi_scan : zig-zag and alternate scan patterns
136 *****************************************************************************/
139 { /* Zig-Zag pattern */
140 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
141 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
142 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
143 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
145 { /* Alternate scan pattern */
146 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
147 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
148 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
149 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
154 * Local inline functions.
157 /*****************************************************************************
158 * ReferenceUpdate : Update the reference pointers when we have a new picture
159 *****************************************************************************/
160 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
162 picture_t * p_newref )
164 if( i_coding_type != B_CODING_TYPE )
166 if( p_vpar->sequence.p_forward != NULL )
168 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
170 if( p_vpar->sequence.p_backward != NULL )
172 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
173 vpar_SynchroDate( p_vpar ) );
175 p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
176 p_vpar->sequence.p_backward = p_newref;
177 if( p_newref != NULL )
179 vout_LinkPicture( p_vpar->p_vout, p_newref );
182 else if( p_newref != NULL )
184 /* Put date immediately. */
185 vout_DatePicture( p_vpar->p_vout, p_newref, vpar_SynchroDate(p_vpar) );
189 /*****************************************************************************
190 * ReferenceReplace : Replace the last reference pointer when we destroy
192 *****************************************************************************/
193 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
195 picture_t * p_newref )
197 if( i_coding_type != B_CODING_TYPE )
199 if( p_vpar->sequence.p_backward != NULL )
201 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
203 p_vpar->sequence.p_backward = p_newref;
204 if( p_newref != NULL )
206 vout_LinkPicture( p_vpar->p_vout, p_newref );
211 /*****************************************************************************
212 * LoadMatrix : Load a quantization matrix
213 *****************************************************************************/
214 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
218 if( !p_matrix->b_allocated )
220 /* Allocate a piece of memory to load the matrix. */
221 if( (p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) )) == NULL )
223 intf_ErrMsg( "vpar error: allocation error in LoadMatrix()" );
224 p_vpar->p_fifo->b_error = 1;
227 p_matrix->b_allocated = 1;
230 for( i_dummy = 0; i_dummy < 64; i_dummy++ )
232 p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
233 = GetBits( &p_vpar->bit_stream, 8 );
237 /* Discrete Fourier Transform requires the quantization matrices to
238 * be normalized before using them. */
239 vdec_NormQuantMatrix( p_matrix->pi_matrix );
243 /*****************************************************************************
244 * LinkMatrix : Link a quantization matrix to another
245 *****************************************************************************/
246 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
248 if( p_matrix->b_allocated )
250 /* Deallocate the piece of memory. */
251 free( p_matrix->pi_matrix );
252 p_matrix->b_allocated = 0;
255 p_matrix->pi_matrix = pi_array;
259 * Exported functions.
262 /*****************************************************************************
263 * vpar_NextSequenceHeader : Find the next sequence header
264 *****************************************************************************/
265 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
267 while( !p_vpar->p_fifo->b_die )
269 NextStartCode( &p_vpar->bit_stream );
270 if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
274 RemoveBits( &p_vpar->bit_stream, 8 );
279 /*****************************************************************************
280 * vpar_ParseHeader : Parse the next header
281 *****************************************************************************/
282 int vpar_ParseHeader( vpar_thread_t * p_vpar )
284 while( !p_vpar->p_fifo->b_die )
286 NextStartCode( &p_vpar->bit_stream );
287 switch( GetBits32( &p_vpar->bit_stream ) )
289 case SEQUENCE_HEADER_CODE:
291 p_vpar->c_sequences++;
293 SequenceHeader( p_vpar );
297 case GROUP_START_CODE:
298 GroupHeader( p_vpar );
302 case PICTURE_START_CODE:
303 PictureHeader( p_vpar );
307 case SEQUENCE_END_CODE:
308 intf_DbgMsg("vpar debug: sequence end code received");
320 * Following functions are local
323 /*****************************************************************************
324 * SequenceHeader : Parse the next sequence header
325 *****************************************************************************/
326 static void SequenceHeader( vpar_thread_t * p_vpar )
329 static int i_frame_rate_table[16] =
340 RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
344 int i_height_save, i_width_save;
346 i_height_save = p_vpar->sequence.i_height;
347 i_width_save = p_vpar->sequence.i_width;
349 p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
350 p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
351 p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
352 p_vpar->sequence.i_frame_rate =
353 i_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
355 /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
356 * constrained_parameters_flag */
357 RemoveBits( &p_vpar->bit_stream, 30 );
360 * Quantization matrices
362 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
364 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
368 /* Use default matrix. */
369 LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
372 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
374 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
378 /* Use default matrix. */
379 LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
382 /* Unless later overwritten by a matrix extension, we have the same
383 * matrices for luminance and chrominance. */
384 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
385 p_vpar->sequence.intra_quant.pi_matrix );
386 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
387 p_vpar->sequence.nonintra_quant.pi_matrix );
392 NextStartCode( &p_vpar->bit_stream );
393 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
397 /* Turn the MPEG2 flag on */
398 p_vpar->sequence.b_mpeg2 = 1;
400 /* Parse sequence_extension */
401 RemoveBits32( &p_vpar->bit_stream );
402 /* extension_start_code_identifier, profile_and_level_indication */
403 RemoveBits( &p_vpar->bit_stream, 12 );
404 p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
405 p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
406 p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
407 p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
408 /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
409 RemoveBits( &p_vpar->bit_stream, 22 );
410 /* frame_rate_extension_n */
411 i_dummy = GetBits( &p_vpar->bit_stream, 2 );
412 /* frame_rate_extension_d */
413 p_vpar->sequence.i_frame_rate *= (i_dummy + 1)
414 / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
418 /* It's an MPEG-1 stream. Put adequate parameters. */
420 p_vpar->sequence.b_mpeg2 = 0;
421 p_vpar->sequence.b_progressive = 1;
422 p_vpar->sequence.i_chroma_format = CHROMA_420;
426 p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
427 p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
428 (p_vpar->sequence.i_height + 15) / 16 :
429 2 * ((p_vpar->sequence.i_height + 31) / 32);
430 p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
431 * p_vpar->sequence.i_mb_height;
432 p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
433 p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
434 p_vpar->sequence.i_size = p_vpar->sequence.i_width
435 * p_vpar->sequence.i_height;
437 /* Update chromatic information. */
438 switch( p_vpar->sequence.i_chroma_format )
441 p_vpar->sequence.i_chroma_nb_blocks = 2;
442 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
443 p_vpar->sequence.i_chroma_mb_width = 8;
444 p_vpar->sequence.i_chroma_mb_height = 8;
448 p_vpar->sequence.i_chroma_nb_blocks = 4;
449 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
450 p_vpar->sequence.i_chroma_mb_width = 8;
451 p_vpar->sequence.i_chroma_mb_height = 16;
455 p_vpar->sequence.i_chroma_nb_blocks = 8;
456 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
457 p_vpar->sequence.i_chroma_mb_width = 16;
458 p_vpar->sequence.i_chroma_mb_height = 16;
461 /* Reset scalable_mode. */
462 p_vpar->sequence.i_scalable_mode = SC_NONE;
465 if( p_vpar->sequence.i_width != i_width_save
466 || p_vpar->sequence.i_height != i_height_save )
468 /* FIXME: What do we do in case of a size change ?? */
472 /* Extension and User data */
473 ExtensionAndUserData( p_vpar );
476 /*****************************************************************************
477 * GroupHeader : Parse the next group of pictures header
478 *****************************************************************************/
479 static void GroupHeader( vpar_thread_t * p_vpar )
481 /* Nothing to do, we don't care. */
482 RemoveBits( &p_vpar->bit_stream, 27 );
483 ExtensionAndUserData( p_vpar );
486 /*****************************************************************************
487 * PictureHeader : Parse the next picture header
488 *****************************************************************************/
489 static void PictureHeader( vpar_thread_t * p_vpar )
493 boolean_t b_parsable;
498 RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
499 p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
500 RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
502 if( p_vpar->picture.i_coding_type == P_CODING_TYPE
503 || p_vpar->picture.i_coding_type == B_CODING_TYPE )
505 p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
506 p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
508 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
510 p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
511 p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
514 /* extra_information_picture */
515 while( GetBits( &p_vpar->bit_stream, 1 ) )
517 RemoveBits( &p_vpar->bit_stream, 8 );
521 * Picture Coding Extension
523 NextStartCode( &p_vpar->bit_stream );
524 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
526 /* Parse picture_coding_extension */
527 RemoveBits32( &p_vpar->bit_stream );
528 /* extension_start_code_identifier */
529 RemoveBits( &p_vpar->bit_stream, 4 );
531 p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
532 p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
533 p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
534 p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
535 p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
536 i_structure = GetBits( &p_vpar->bit_stream, 2 );
537 p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
538 p_vpar->picture.b_frame_pred_frame_dct
539 = GetBits( &p_vpar->bit_stream, 1 );
540 p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
541 p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
542 p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
543 p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
544 p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
545 /* chroma_420_type (obsolete) */
546 RemoveBits( &p_vpar->bit_stream, 1 );
547 p_vpar->picture.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
549 /* composite_display_flag */
550 if( GetBits( &p_vpar->bit_stream, 1 ) )
552 /* v_axis, field_sequence, sub_carrier, burst_amplitude,
553 * sub_carrier_phase */
554 RemoveBits( &p_vpar->bit_stream, 20 );
559 /* MPEG-1 compatibility flags */
560 p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
561 i_structure = FRAME_STRUCTURE;
562 p_vpar->picture.b_top_field_first = 0;
563 p_vpar->picture.b_frame_pred_frame_dct = 1;
564 p_vpar->picture.b_concealment_mv = 0;
565 p_vpar->picture.b_q_scale_type = 0;
566 p_vpar->picture.b_intra_vlc_format = 0;
567 p_vpar->picture.b_alternate_scan = 0; /* zigzag */
568 p_vpar->picture.b_repeat_first_field = 1; /* FIXME! this contradicts
570 p_vpar->picture.b_progressive = 1;
574 p_vpar->pc_pictures[p_vpar->picture.i_coding_type]++;
577 if( p_vpar->picture.i_current_structure &&
578 (i_structure == FRAME_STRUCTURE ||
579 i_structure == p_vpar->picture.i_current_structure) )
581 /* We don't have the second field of the buffered frame. */
582 if( p_vpar->picture.p_picture != NULL )
584 ReferenceReplace( p_vpar,
585 p_vpar->picture.i_coding_type,
589 for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
591 vpar_DestroyMacroblock( &p_vpar->vfifo,
592 p_vpar->picture.pp_mb[i_mb] );
595 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
598 p_vpar->picture.i_current_structure = 0;
600 intf_DbgMsg("vpar debug: odd number of field picture.");
603 /* Do we have the reference pictures ? */
604 b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
605 (p_vpar->sequence.p_backward == NULL)) ||
606 /* p_backward will become p_forward later */
607 ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
608 (p_vpar->sequence.p_forward == NULL ||
609 p_vpar->sequence.p_backward == NULL)));
611 if( p_vpar->picture.i_current_structure )
613 /* Second field of a frame. We will decode it if, and only if we
614 * have decoded the first field. */
617 b_parsable = (p_vpar->picture.p_picture != NULL);
624 /* Compute the number of times the frame will be emitted by the
625 * decoder (number of periods). */
626 if( p_vpar->sequence.b_progressive )
628 i_repeat_field = 1 + p_vpar->picture.b_repeat_first_field
629 + p_vpar->picture.b_top_field_first;
633 if( p_vpar->picture.b_progressive )
635 i_repeat_field = 2 + p_vpar->picture.b_repeat_first_field;
643 /* Warn synchro we have a new picture (updates pictures index). */
644 vpar_SynchroNewPicture( p_vpar, p_vpar->picture.i_coding_type,
649 /* Does synchro say we have enough time to decode it ? */
650 b_parsable = vpar_SynchroChoose( p_vpar,
651 p_vpar->picture.i_coding_type, i_structure );
657 /* Update the reference pointers. */
658 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
660 /* Update context. */
661 if( i_structure != FRAME_STRUCTURE )
663 if( (p_vpar->picture.i_current_structure | i_structure)
666 p_vpar->picture.i_current_structure = 0;
670 /* The frame is complete. */
671 p_vpar->picture.i_current_structure = i_structure;
673 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
678 /* Warn Synchro we have trashed a picture. */
679 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
681 p_vpar->picture.p_picture = NULL;
686 /* OK, now we are sure we will decode the picture. */
688 p_vpar->pc_decoded_pictures[p_vpar->picture.i_coding_type]++;
691 #define P_picture p_vpar->picture.p_picture
692 p_vpar->picture.b_error = 0;
693 p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
695 if( !p_vpar->picture.i_current_structure )
697 /* This is a new frame. Get a structure from the video_output. */
698 while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
699 99+p_vpar->sequence.i_chroma_format, /*XXX??*/
700 p_vpar->sequence.i_width,
701 p_vpar->sequence.i_height ) )
704 intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying");
705 if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
709 msleep( VPAR_OUTMEM_SLEEP );
712 /* Initialize values. */
713 vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
714 P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
715 P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
716 p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
717 << ( 1 - p_vpar->picture.b_frame_structure ) );
718 p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
719 << ( 1 - p_vpar->picture.b_frame_structure ));
721 P_picture->i_deccount = p_vpar->sequence.i_mb_size;
723 memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
725 /* FIXME ! remove asap ?? */
726 memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
728 /* Update the reference pointers. */
729 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
732 /* Link referenced pictures for the decoder
733 * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
734 if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
735 p_vpar->picture.i_coding_type == B_CODING_TYPE )
737 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
739 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
741 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
745 p_vpar->picture.i_current_structure |= i_structure;
746 p_vpar->picture.i_structure = i_structure;
748 /* Initialize picture data for decoding. */
749 if( i_structure == BOTTOM_FIELD )
751 i_mb_base = p_vpar->sequence.i_mb_size >> 1;
752 p_vpar->mb.i_l_y = 1;
753 p_vpar->mb.i_c_y = 1;
758 p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
760 p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
762 /* Extension and User data. */
763 ExtensionAndUserData( p_vpar );
765 vpar_PictureData( p_vpar, i_mb_base );
767 if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
772 if( p_vpar->picture.b_error )
776 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
778 vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
783 p_vpar->pc_malformed_pictures[p_vpar->picture.i_coding_type]++;
786 if( P_picture->i_deccount != 1 )
788 vpar_SynchroEnd( p_vpar, 1 );
789 vout_DestroyPicture( p_vpar->p_vout, P_picture );
792 ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
794 /* Prepare context for the next picture. */
796 if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
797 p_vpar->picture.i_current_structure = 0;
799 else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
801 /* Frame completely parsed. */
803 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
805 vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
808 /* Send signal to the video_decoder. */
809 vlc_mutex_lock( &p_vpar->vfifo.lock );
810 vlc_cond_signal( &p_vpar->vfifo.wait );
811 vlc_mutex_unlock( &p_vpar->vfifo.lock );
814 /* Prepare context for the next picture. */
816 p_vpar->picture.i_current_structure = 0;
821 /*****************************************************************************
822 * ExtensionAndUserData : Parse the extension_and_user_data structure
823 *****************************************************************************/
824 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
826 while( !p_vpar->p_fifo->b_die )
828 NextStartCode( &p_vpar->bit_stream );
829 switch( ShowBits( &p_vpar->bit_stream, 32 ) )
831 case EXTENSION_START_CODE:
832 RemoveBits32( &p_vpar->bit_stream );
833 switch( GetBits( &p_vpar->bit_stream, 4 ) )
835 case SEQUENCE_DISPLAY_EXTENSION_ID:
836 SequenceDisplayExtension( p_vpar );
838 case QUANT_MATRIX_EXTENSION_ID:
839 QuantMatrixExtension( p_vpar );
841 case SEQUENCE_SCALABLE_EXTENSION_ID:
842 SequenceScalableExtension( p_vpar );
844 case PICTURE_DISPLAY_EXTENSION_ID:
845 PictureDisplayExtension( p_vpar );
847 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
848 PictureSpatialScalableExtension( p_vpar );
850 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
851 PictureTemporalScalableExtension( p_vpar );
853 case COPYRIGHT_EXTENSION_ID:
854 CopyrightExtension( p_vpar );
860 case USER_DATA_START_CODE:
861 RemoveBits32( &p_vpar->bit_stream );
862 /* Wait for the next start code */
872 /*****************************************************************************
873 * SequenceDisplayExtension : Parse the sequence_display_extension structure *
874 *****************************************************************************/
876 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
878 /* We don't care sequence_display_extension. */
880 RemoveBits( &p_vpar->bit_stream, 3 );
881 if( GetBits( &p_vpar->bit_stream, 1 ) )
883 /* Two bytes for color_desciption */
884 RemoveBits( &p_vpar->bit_stream, 16 );
885 p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
887 /* display_horizontal and vertical_size and a marker_bit */
888 RemoveBits( &p_vpar->bit_stream, 29 );
892 /*****************************************************************************
893 * QuantMatrixExtension : Load quantization matrices for luminance *
895 *****************************************************************************/
897 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
899 if( GetBits( &p_vpar->bit_stream, 1 ) )
901 /* Load intra_quantiser_matrix for luminance. */
902 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
906 /* Use the default matrix. */
907 LinkMatrix( &p_vpar->sequence.intra_quant,
908 pi_default_intra_quant );
910 if( GetBits( &p_vpar->bit_stream, 1 ) )
912 /* Load non_intra_quantiser_matrix for luminance. */
913 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
917 /* Use the default matrix. */
918 LinkMatrix( &p_vpar->sequence.nonintra_quant,
919 pi_default_nonintra_quant );
921 if( GetBits( &p_vpar->bit_stream, 1 ) )
923 /* Load intra_quantiser_matrix for chrominance. */
924 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
928 /* Link the chrominance intra matrix to the luminance one. */
929 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
930 p_vpar->sequence.intra_quant.pi_matrix );
932 if( GetBits( &p_vpar->bit_stream, 1 ) )
934 /* Load non_intra_quantiser_matrix for chrominance. */
935 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
939 /* Link the chrominance intra matrix to the luminance one. */
940 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
941 p_vpar->sequence.intra_quant.pi_matrix );
943 if( GetBits( &p_vpar->bit_stream, 1 ) )
945 /* Load non_intra_quantiser_matrix for chrominance. */
946 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
950 /* Link the chrominance nonintra matrix to the luminance one. */
951 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
952 p_vpar->sequence.nonintra_quant.pi_matrix );
957 /*****************************************************************************
958 * SequenceScalableExtension : Parse the sequence_scalable_extension *
959 * structure to handle scalable coding *
960 *****************************************************************************/
962 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
964 /* We don't care about anything scalable except the scalable mode. */
965 switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
966 /* The length of the structure depends on the value of the scalable_mode */
969 RemoveBits32( &p_vpar->bit_stream );
970 RemoveBits( &p_vpar->bit_stream, 21 );
973 RemoveBits( &p_vpar->bit_stream, 12 );
976 RemoveBits( &p_vpar->bit_stream, 4 );
980 /*****************************************************************************
981 * PictureDisplayExtension : Parse the picture_display_extension structure *
982 *****************************************************************************/
984 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
986 /* Number of frame center offset */
988 /* I am not sure it works but it should
989 (fewer tests than shown in §6.3.12) */
990 i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
991 p_vpar->picture.b_repeat_first_field +
992 p_vpar->picture.b_top_field_first
993 : ( p_vpar->picture.b_frame_structure + 1 ) +
994 p_vpar->picture.b_repeat_first_field;
995 for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
997 RemoveBits( &p_vpar->bit_stream, 17 );
998 RemoveBits( &p_vpar->bit_stream, 17 );
1003 /*****************************************************************************
1004 * PictureSpatialScalableExtension *
1005 *****************************************************************************/
1007 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
1009 /* That's scalable, so we trash it */
1010 RemoveBits32( &p_vpar->bit_stream );
1011 RemoveBits( &p_vpar->bit_stream, 16 );
1015 /*****************************************************************************
1016 * PictureTemporalScalableExtension *
1017 *****************************************************************************/
1019 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
1021 /* Scalable again, trashed again */
1022 RemoveBits( &p_vpar->bit_stream, 23 );
1026 /*****************************************************************************
1027 * CopyrightExtension : Keeps some legal informations *
1028 *****************************************************************************/
1030 static void CopyrightExtension( vpar_thread_t * p_vpar )
1032 u32 i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1033 p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1034 /* A flag that says whether the copyright information is significant */
1035 p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1036 /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1037 p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1039 RemoveBits( &p_vpar->bit_stream, 8 );
1040 /* The copyright_number is split in three parts */
1042 i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1043 RemoveBits( &p_vpar->bit_stream, 1 );
1045 i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1046 RemoveBits( &p_vpar->bit_stream, 1 );
1047 /* third part and sum */
1048 p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1049 ( (u64)i_copyright_nb_2 << 22 ) |
1050 ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );