1 /*****************************************************************************
2 * vpar_headers.c : headers parsing
3 *****************************************************************************
4 * Copyright (C) 1999, 2000 VideoLAN
5 * $Id: vpar_headers.c,v 1.62 2000/12/22 13:04:45 sam 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() */
31 #include <sys/types.h> /* on BSD, uio.h needs types.h */
32 #include <sys/uio.h> /* "input.h" */
42 #include "stream_control.h"
43 #include "input_ext-dec.h"
46 #include "video_output.h"
48 #include "../video_decoder/vdec_idct.h"
49 #include "../video_decoder/video_decoder.h"
50 #include "../video_decoder/vdec_motion.h"
52 #include "../video_decoder/vpar_blocks.h"
53 #include "../video_decoder/vpar_headers.h"
54 #include "../video_decoder/vpar_synchro.h"
55 #include "../video_decoder/video_parser.h"
56 #include "../video_decoder/video_fifo.h"
61 static __inline__ void NextStartCode( bit_stream_t * );
62 static void SequenceHeader( vpar_thread_t * p_vpar );
63 static void GroupHeader( vpar_thread_t * p_vpar );
64 static void PictureHeader( vpar_thread_t * p_vpar );
65 static void ExtensionAndUserData( vpar_thread_t * p_vpar );
66 static void QuantMatrixExtension( vpar_thread_t * p_vpar );
67 static void SequenceScalableExtension( vpar_thread_t * p_vpar );
68 static void SequenceDisplayExtension( vpar_thread_t * p_vpar );
69 static void PictureDisplayExtension( vpar_thread_t * p_vpar );
70 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar );
71 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar );
72 static void CopyrightExtension( vpar_thread_t * p_vpar );
78 /*****************************************************************************
79 * pi_default_intra_quant : default quantization matrix
80 *****************************************************************************/
82 int pi_default_intra_quant[] =
84 8, 16, 19, 22, 26, 27, 29, 34,
85 16, 16, 22, 24, 27, 29, 34, 37,
86 19, 22, 26, 27, 29, 34, 34, 38,
87 22, 22, 26, 27, 29, 34, 37, 40,
88 22, 26, 27, 29, 32, 35, 40, 48,
89 26, 27, 29, 32, 35, 40, 48, 58,
90 26, 27, 29, 34, 38, 46, 56, 69,
91 27, 29, 35, 38, 46, 56, 69, 83
94 int pi_default_intra_quant[] =
96 2048, 5681, 6355, 6623, 6656, 5431, 4018, 2401,
97 5681, 7880, 10207, 10021, 9587, 8091, 6534, 3625,
98 6355, 10207, 11363, 10619, 9700, 8935, 6155, 3507,
99 6623, 9186, 10226, 9557, 8730, 8041, 6028, 3322,
100 5632, 9232, 9031, 8730, 8192, 7040, 5542, 3390,
101 5230, 7533, 7621, 7568, 7040, 6321, 5225, 3219,
102 3602, 5189, 5250, 5539, 5265, 5007, 4199, 2638,
103 1907, 2841, 3230, 3156, 3249, 3108, 2638, 1617
107 /*****************************************************************************
108 * pi_default_nonintra_quant : default quantization matrix
109 *****************************************************************************/
111 int pi_default_nonintra_quant[] =
113 16, 16, 16, 16, 16, 16, 16, 16,
114 16, 16, 16, 16, 16, 16, 16, 16,
115 16, 16, 16, 16, 16, 16, 16, 16,
116 16, 16, 16, 16, 16, 16, 16, 16,
117 16, 16, 16, 16, 16, 16, 16, 16,
118 16, 16, 16, 16, 16, 16, 16, 16,
119 16, 16, 16, 16, 16, 16, 16, 16,
120 16, 16, 16, 16, 16, 16, 16, 16
123 int pi_default_nonintra_quanit[] =
125 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
126 5680, 7888, 7424, 6688, 5680, 4464, 3072, 1568,
127 5344, 7424, 6992, 6288, 5344, 4208, 2896, 1472,
128 4816, 6688, 6288, 5664, 4816, 3792, 2608, 1328,
129 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
130 3216, 4464, 4208, 3792, 3216, 2528, 1744, 880,
131 2224, 3072, 2896, 2608, 2224, 1744, 1200, 608,
132 1136, 1568, 1472, 1328, 1136, 880, 608, 304
136 /*****************************************************************************
137 * pi_scan : zig-zag and alternate scan patterns
138 *****************************************************************************/
141 { /* Zig-Zag pattern */
142 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
143 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
144 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
145 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
147 { /* Alternate scan pattern */
148 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
149 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
150 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
151 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
156 * Local inline functions.
159 /*****************************************************************************
160 * ReferenceUpdate : Update the reference pointers when we have a new picture
161 *****************************************************************************/
162 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
164 picture_t * p_newref )
166 if( i_coding_type != B_CODING_TYPE )
168 if( p_vpar->sequence.p_forward != NULL )
170 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
172 if( p_vpar->sequence.p_backward != NULL )
174 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
175 vpar_SynchroDate( p_vpar ) );
177 p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
178 p_vpar->sequence.p_backward = p_newref;
179 if( p_newref != NULL )
181 vout_LinkPicture( p_vpar->p_vout, p_newref );
184 else if( p_newref != NULL )
186 /* Put date immediately. */
187 vout_DatePicture( p_vpar->p_vout, p_newref, vpar_SynchroDate(p_vpar) );
191 /*****************************************************************************
192 * ReferenceReplace : Replace the last reference pointer when we destroy
194 *****************************************************************************/
195 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
197 picture_t * p_newref )
199 if( i_coding_type != B_CODING_TYPE )
201 if( p_vpar->sequence.p_backward != NULL )
203 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
205 p_vpar->sequence.p_backward = p_newref;
206 if( p_newref != NULL )
208 vout_LinkPicture( p_vpar->p_vout, p_newref );
213 /*****************************************************************************
214 * LoadMatrix : Load a quantization matrix
215 *****************************************************************************/
216 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
220 if( !p_matrix->b_allocated )
222 /* Allocate a piece of memory to load the matrix. */
223 if( (p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) )) == NULL )
225 intf_ErrMsg( "vpar error: allocation error in LoadMatrix()" );
226 p_vpar->p_fifo->b_error = 1;
229 p_matrix->b_allocated = 1;
232 for( i_dummy = 0; i_dummy < 64; i_dummy++ )
234 p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
235 = GetBits( &p_vpar->bit_stream, 8 );
239 /* Discrete Fourier Transform requires the quantization matrices to
240 * be normalized before using them. */
241 vdec_NormQuantMatrix( p_matrix->pi_matrix );
245 /*****************************************************************************
246 * LinkMatrix : Link a quantization matrix to another
247 *****************************************************************************/
248 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
250 if( p_matrix->b_allocated )
252 /* Deallocate the piece of memory. */
253 free( p_matrix->pi_matrix );
254 p_matrix->b_allocated = 0;
257 p_matrix->pi_matrix = pi_array;
261 * Exported functions.
264 /*****************************************************************************
265 * vpar_NextSequenceHeader : Find the next sequence header
266 *****************************************************************************/
267 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
269 while( !p_vpar->p_fifo->b_die )
271 NextStartCode( &p_vpar->bit_stream );
272 if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
276 RemoveBits( &p_vpar->bit_stream, 8 );
281 /*****************************************************************************
282 * vpar_ParseHeader : Parse the next header
283 *****************************************************************************/
284 int vpar_ParseHeader( vpar_thread_t * p_vpar )
286 while( !p_vpar->p_fifo->b_die )
288 NextStartCode( &p_vpar->bit_stream );
289 switch( GetBits32( &p_vpar->bit_stream ) )
291 case SEQUENCE_HEADER_CODE:
293 p_vpar->c_sequences++;
295 SequenceHeader( p_vpar );
299 case GROUP_START_CODE:
300 GroupHeader( p_vpar );
304 case PICTURE_START_CODE:
305 PictureHeader( p_vpar );
309 case SEQUENCE_END_CODE:
310 intf_DbgMsg("vpar debug: sequence end code received");
322 * Following functions are local
325 /*****************************************************************************
326 * SequenceHeader : Parse the next sequence header
327 *****************************************************************************/
328 static void SequenceHeader( vpar_thread_t * p_vpar )
331 static int i_frame_rate_table[16] =
342 RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
346 int i_height_save, i_width_save;
348 i_height_save = p_vpar->sequence.i_height;
349 i_width_save = p_vpar->sequence.i_width;
351 p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
352 p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
353 p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
354 p_vpar->sequence.i_frame_rate =
355 i_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
357 /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
358 * constrained_parameters_flag */
359 RemoveBits( &p_vpar->bit_stream, 30 );
362 * Quantization matrices
364 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
366 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
370 /* Use default matrix. */
371 LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
374 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
376 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
380 /* Use default matrix. */
381 LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
384 /* Unless later overwritten by a matrix extension, we have the same
385 * matrices for luminance and chrominance. */
386 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
387 p_vpar->sequence.intra_quant.pi_matrix );
388 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
389 p_vpar->sequence.nonintra_quant.pi_matrix );
394 NextStartCode( &p_vpar->bit_stream );
395 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
399 /* Turn the MPEG2 flag on */
400 p_vpar->sequence.b_mpeg2 = 1;
402 /* Parse sequence_extension */
403 RemoveBits32( &p_vpar->bit_stream );
404 /* extension_start_code_identifier, profile_and_level_indication */
405 RemoveBits( &p_vpar->bit_stream, 12 );
406 p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
407 p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
408 p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
409 p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
410 /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
411 RemoveBits( &p_vpar->bit_stream, 22 );
412 /* frame_rate_extension_n */
413 i_dummy = GetBits( &p_vpar->bit_stream, 2 );
414 /* frame_rate_extension_d */
415 p_vpar->sequence.i_frame_rate *= (i_dummy + 1)
416 / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
420 /* It's an MPEG-1 stream. Put adequate parameters. */
422 p_vpar->sequence.b_mpeg2 = 0;
423 p_vpar->sequence.b_progressive = 1;
424 p_vpar->sequence.i_chroma_format = CHROMA_420;
428 p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
429 p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
430 (p_vpar->sequence.i_height + 15) / 16 :
431 2 * ((p_vpar->sequence.i_height + 31) / 32);
432 p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
433 * p_vpar->sequence.i_mb_height;
434 p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
435 p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
436 p_vpar->sequence.i_size = p_vpar->sequence.i_width
437 * p_vpar->sequence.i_height;
439 /* Update chromatic information. */
440 switch( p_vpar->sequence.i_chroma_format )
443 p_vpar->sequence.i_chroma_nb_blocks = 2;
444 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
445 p_vpar->sequence.i_chroma_mb_width = 8;
446 p_vpar->sequence.i_chroma_mb_height = 8;
450 p_vpar->sequence.i_chroma_nb_blocks = 4;
451 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
452 p_vpar->sequence.i_chroma_mb_width = 8;
453 p_vpar->sequence.i_chroma_mb_height = 16;
457 p_vpar->sequence.i_chroma_nb_blocks = 8;
458 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
459 p_vpar->sequence.i_chroma_mb_width = 16;
460 p_vpar->sequence.i_chroma_mb_height = 16;
463 /* Reset scalable_mode. */
464 p_vpar->sequence.i_scalable_mode = SC_NONE;
467 if( p_vpar->sequence.i_width != i_width_save
468 || p_vpar->sequence.i_height != i_height_save )
470 /* FIXME: What do we do in case of a size change ?? */
474 /* Extension and User data */
475 ExtensionAndUserData( p_vpar );
478 /*****************************************************************************
479 * GroupHeader : Parse the next group of pictures header
480 *****************************************************************************/
481 static void GroupHeader( vpar_thread_t * p_vpar )
483 /* Nothing to do, we don't care. */
484 RemoveBits( &p_vpar->bit_stream, 27 );
485 ExtensionAndUserData( p_vpar );
488 /*****************************************************************************
489 * PictureHeader : Parse the next picture header
490 *****************************************************************************/
491 static void PictureHeader( vpar_thread_t * p_vpar )
495 boolean_t b_parsable;
500 RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
501 p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
502 RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
504 if( p_vpar->picture.i_coding_type == P_CODING_TYPE
505 || p_vpar->picture.i_coding_type == B_CODING_TYPE )
507 p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
508 p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
510 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
512 p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
513 p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
516 /* extra_information_picture */
517 while( GetBits( &p_vpar->bit_stream, 1 ) )
519 RemoveBits( &p_vpar->bit_stream, 8 );
523 * Picture Coding Extension
525 NextStartCode( &p_vpar->bit_stream );
526 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
528 /* Parse picture_coding_extension */
529 RemoveBits32( &p_vpar->bit_stream );
530 /* extension_start_code_identifier */
531 RemoveBits( &p_vpar->bit_stream, 4 );
533 p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
534 p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
535 p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
536 p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
537 p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
538 i_structure = GetBits( &p_vpar->bit_stream, 2 );
539 p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
540 p_vpar->picture.b_frame_pred_frame_dct
541 = GetBits( &p_vpar->bit_stream, 1 );
542 p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
543 p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
544 p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
545 p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
546 p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
547 /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
548 * the length of the picture_display_extension structure.
549 * chroma_420_type (obsolete) */
550 RemoveBits( &p_vpar->bit_stream, 1 );
551 p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
553 /* composite_display_flag */
554 if( GetBits( &p_vpar->bit_stream, 1 ) )
556 /* v_axis, field_sequence, sub_carrier, burst_amplitude,
557 * sub_carrier_phase */
558 RemoveBits( &p_vpar->bit_stream, 20 );
563 /* MPEG-1 compatibility flags */
564 p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
565 i_structure = FRAME_STRUCTURE;
566 p_vpar->picture.b_frame_pred_frame_dct = 1;
567 p_vpar->picture.b_concealment_mv = 0;
568 p_vpar->picture.b_q_scale_type = 0;
569 p_vpar->picture.b_intra_vlc_format = 0;
570 p_vpar->picture.b_alternate_scan = 0; /* zigzag */
571 p_vpar->picture.b_repeat_first_field = 0;
572 p_vpar->picture.b_progressive_frame = 1;
576 p_vpar->pc_pictures[p_vpar->picture.i_coding_type]++;
579 if( p_vpar->picture.i_current_structure &&
580 (i_structure == FRAME_STRUCTURE ||
581 i_structure == p_vpar->picture.i_current_structure) )
583 /* We don't have the second field of the buffered frame. */
584 if( p_vpar->picture.p_picture != NULL )
586 ReferenceReplace( p_vpar,
587 p_vpar->picture.i_coding_type,
591 for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
593 vpar_DestroyMacroblock( &p_vpar->vfifo,
594 p_vpar->picture.pp_mb[i_mb] );
597 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
600 p_vpar->picture.i_current_structure = 0;
602 intf_DbgMsg("vpar debug: odd number of field picture.");
605 /* Do we have the reference pictures ? */
606 b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
607 (p_vpar->sequence.p_backward == NULL)) ||
608 /* p_backward will become p_forward later */
609 ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
610 (p_vpar->sequence.p_forward == NULL ||
611 p_vpar->sequence.p_backward == NULL)));
615 if( p_vpar->picture.i_current_structure )
617 /* Second field of a frame. We will decode it if, and only if we
618 * have decoded the first field. */
619 b_parsable = (p_vpar->picture.p_picture != NULL);
623 /* Does synchro say we have enough time to decode it ? */
624 b_parsable = vpar_SynchroChoose( p_vpar,
625 p_vpar->picture.i_coding_type, i_structure );
631 /* Update the reference pointers. */
632 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
634 /* Update context. */
635 if( i_structure != FRAME_STRUCTURE )
637 if( (p_vpar->picture.i_current_structure | i_structure)
640 p_vpar->picture.i_current_structure = 0;
644 /* The frame is complete. */
645 p_vpar->picture.i_current_structure = i_structure;
646 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
651 /* Warn Synchro we have trashed a picture. */
652 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
654 p_vpar->picture.p_picture = NULL;
659 /* OK, now we are sure we will decode the picture. */
661 p_vpar->pc_decoded_pictures[p_vpar->picture.i_coding_type]++;
664 #define P_picture p_vpar->picture.p_picture
665 p_vpar->picture.b_error = 0;
666 p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
668 if( !p_vpar->picture.i_current_structure )
670 /* This is a new frame. Get a structure from the video_output. */
671 while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
672 99+p_vpar->sequence.i_chroma_format, /*XXX??*/
673 p_vpar->sequence.i_width,
674 p_vpar->sequence.i_height ) )
677 intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying");
678 if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
682 msleep( VPAR_OUTMEM_SLEEP );
685 /* Initialize values. */
686 vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
687 P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
688 P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
689 p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
690 << ( 1 - p_vpar->picture.b_frame_structure ) );
691 p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
692 << ( 1 - p_vpar->picture.b_frame_structure ));
694 P_picture->i_deccount = p_vpar->sequence.i_mb_size;
695 vlc_mutex_init( &p_vpar->picture.p_picture->lock_deccount );
697 memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
699 /* FIXME ! remove asap ?? */
700 //memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
702 /* Update the reference pointers. */
703 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
706 /* Link referenced pictures for the decoder
707 * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
708 if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
709 p_vpar->picture.i_coding_type == B_CODING_TYPE )
711 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
713 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
715 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
719 p_vpar->picture.i_current_structure |= i_structure;
720 p_vpar->picture.i_structure = i_structure;
722 /* Initialize picture data for decoding. */
723 if( i_structure == BOTTOM_FIELD )
725 i_mb_base = p_vpar->sequence.i_mb_size >> 1;
726 p_vpar->mb.i_l_y = 1;
727 p_vpar->mb.i_c_y = 1;
732 p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
734 p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
736 /* Extension and User data. */
737 ExtensionAndUserData( p_vpar );
739 vpar_PictureData( p_vpar, i_mb_base );
741 if( p_vpar->p_fifo->b_die || p_vpar->p_fifo->b_error )
746 if( p_vpar->picture.b_error )
749 //fprintf(stderr, "Image trashee\n");
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 //fprintf(stderr, "Image parsee (%d)\n", p_vpar->picture.i_coding_type);
777 /* Frame completely parsed. */
779 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
781 vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
784 /* Send signal to the video_decoder. */
785 vlc_mutex_lock( &p_vpar->vfifo.lock );
786 vlc_cond_signal( &p_vpar->vfifo.wait );
787 vlc_mutex_unlock( &p_vpar->vfifo.lock );
790 /* Prepare context for the next picture. */
792 p_vpar->picture.i_current_structure = 0;
797 /*****************************************************************************
798 * ExtensionAndUserData : Parse the extension_and_user_data structure
799 *****************************************************************************/
800 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
802 while( !p_vpar->p_fifo->b_die )
804 NextStartCode( &p_vpar->bit_stream );
805 switch( ShowBits( &p_vpar->bit_stream, 32 ) )
807 case EXTENSION_START_CODE:
808 RemoveBits32( &p_vpar->bit_stream );
809 switch( GetBits( &p_vpar->bit_stream, 4 ) )
811 case SEQUENCE_DISPLAY_EXTENSION_ID:
812 SequenceDisplayExtension( p_vpar );
814 case QUANT_MATRIX_EXTENSION_ID:
815 QuantMatrixExtension( p_vpar );
817 case SEQUENCE_SCALABLE_EXTENSION_ID:
818 SequenceScalableExtension( p_vpar );
820 case PICTURE_DISPLAY_EXTENSION_ID:
821 PictureDisplayExtension( p_vpar );
823 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
824 PictureSpatialScalableExtension( p_vpar );
826 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
827 PictureTemporalScalableExtension( p_vpar );
829 case COPYRIGHT_EXTENSION_ID:
830 CopyrightExtension( p_vpar );
836 case USER_DATA_START_CODE:
837 RemoveBits32( &p_vpar->bit_stream );
838 /* Wait for the next start code */
848 /*****************************************************************************
849 * SequenceDisplayExtension : Parse the sequence_display_extension structure *
850 *****************************************************************************/
852 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
854 /* We don't care sequence_display_extension. */
856 RemoveBits( &p_vpar->bit_stream, 3 );
857 if( GetBits( &p_vpar->bit_stream, 1 ) )
859 /* Two bytes for color_desciption */
860 RemoveBits( &p_vpar->bit_stream, 16 );
861 p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
863 /* display_horizontal and vertical_size and a marker_bit */
864 RemoveBits( &p_vpar->bit_stream, 29 );
868 /*****************************************************************************
869 * QuantMatrixExtension : Load quantization matrices for luminance *
871 *****************************************************************************/
873 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
875 if( GetBits( &p_vpar->bit_stream, 1 ) )
877 /* Load intra_quantiser_matrix for luminance. */
878 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
882 /* Use the default matrix. */
883 LinkMatrix( &p_vpar->sequence.intra_quant,
884 pi_default_intra_quant );
886 if( GetBits( &p_vpar->bit_stream, 1 ) )
888 /* Load non_intra_quantiser_matrix for luminance. */
889 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
893 /* Use the default matrix. */
894 LinkMatrix( &p_vpar->sequence.nonintra_quant,
895 pi_default_nonintra_quant );
897 if( GetBits( &p_vpar->bit_stream, 1 ) )
899 /* Load intra_quantiser_matrix for chrominance. */
900 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
904 /* Link the chrominance intra matrix to the luminance one. */
905 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
906 p_vpar->sequence.intra_quant.pi_matrix );
908 if( GetBits( &p_vpar->bit_stream, 1 ) )
910 /* Load non_intra_quantiser_matrix for chrominance. */
911 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
915 /* Link the chrominance intra matrix to the luminance one. */
916 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
917 p_vpar->sequence.intra_quant.pi_matrix );
919 if( GetBits( &p_vpar->bit_stream, 1 ) )
921 /* Load non_intra_quantiser_matrix for chrominance. */
922 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
926 /* Link the chrominance nonintra matrix to the luminance one. */
927 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
928 p_vpar->sequence.nonintra_quant.pi_matrix );
933 /*****************************************************************************
934 * SequenceScalableExtension : Parse the sequence_scalable_extension *
935 * structure to handle scalable coding *
936 *****************************************************************************/
938 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
940 /* We don't care about anything scalable except the scalable mode. */
941 switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
942 /* The length of the structure depends on the value of the scalable_mode */
945 RemoveBits32( &p_vpar->bit_stream );
946 RemoveBits( &p_vpar->bit_stream, 21 );
949 RemoveBits( &p_vpar->bit_stream, 12 );
952 RemoveBits( &p_vpar->bit_stream, 4 );
956 /*****************************************************************************
957 * PictureDisplayExtension : Parse the picture_display_extension structure *
958 *****************************************************************************/
960 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
962 /* Number of frame center offset */
964 /* I am not sure it works but it should
965 (fewer tests than shown in §6.3.12) */
966 i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
967 p_vpar->picture.b_repeat_first_field +
968 p_vpar->picture.b_top_field_first
969 : ( p_vpar->picture.b_frame_structure + 1 ) +
970 p_vpar->picture.b_repeat_first_field;
971 for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
973 RemoveBits( &p_vpar->bit_stream, 17 );
974 RemoveBits( &p_vpar->bit_stream, 17 );
979 /*****************************************************************************
980 * PictureSpatialScalableExtension *
981 *****************************************************************************/
983 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
985 /* That's scalable, so we trash it */
986 RemoveBits32( &p_vpar->bit_stream );
987 RemoveBits( &p_vpar->bit_stream, 16 );
991 /*****************************************************************************
992 * PictureTemporalScalableExtension *
993 *****************************************************************************/
995 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
997 /* Scalable again, trashed again */
998 RemoveBits( &p_vpar->bit_stream, 23 );
1002 /*****************************************************************************
1003 * CopyrightExtension : Keeps some legal informations *
1004 *****************************************************************************/
1006 static void CopyrightExtension( vpar_thread_t * p_vpar )
1008 u32 i_copyright_nb_1, i_copyright_nb_2; /* local integers */
1009 p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
1010 /* A flag that says whether the copyright information is significant */
1011 p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
1012 /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
1013 p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
1015 RemoveBits( &p_vpar->bit_stream, 8 );
1016 /* The copyright_number is split in three parts */
1018 i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
1019 RemoveBits( &p_vpar->bit_stream, 1 );
1021 i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1022 RemoveBits( &p_vpar->bit_stream, 1 );
1023 /* third part and sum */
1024 p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1025 ( (u64)i_copyright_nb_2 << 22 ) |
1026 ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );