1 /*****************************************************************************
2 * vpar_headers.c : headers parsing
3 *****************************************************************************
4 * Copyright (C) 1999, 2000 VideoLAN
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
21 *****************************************************************************/
23 /*****************************************************************************
25 *****************************************************************************/
28 #include <stdlib.h> /* free() */
29 #include <sys/types.h> /* on BSD, uio.h needs types.h */
30 #include <sys/uio.h> /* "input.h" */
41 #include "decoder_fifo.h"
43 #include "video_output.h"
45 #include "vdec_idct.h"
46 #include "video_decoder.h"
47 #include "vdec_motion.h"
49 #include "vpar_blocks.h"
50 #include "vpar_headers.h"
51 #include "vpar_synchro.h"
52 #include "video_parser.h"
53 #include "video_fifo.h"
58 static __inline__ void NextStartCode( vpar_thread_t * p_vpar );
59 static void SequenceHeader( vpar_thread_t * p_vpar );
60 static void GroupHeader( vpar_thread_t * p_vpar );
61 static void PictureHeader( vpar_thread_t * p_vpar );
62 static void ExtensionAndUserData( vpar_thread_t * p_vpar );
63 static void QuantMatrixExtension( vpar_thread_t * p_vpar );
64 static void SequenceScalableExtension( vpar_thread_t * p_vpar );
65 static void SequenceDisplayExtension( vpar_thread_t * p_vpar );
66 static void PictureDisplayExtension( vpar_thread_t * p_vpar );
67 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar );
68 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar );
69 static void CopyrightExtension( vpar_thread_t * p_vpar );
75 /*****************************************************************************
76 * pi_default_intra_quant : default quantization matrix
77 *****************************************************************************/
79 int 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 int pi_default_intra_quant[] =
93 2048, 5681, 6355, 6623, 6656, 5431, 4018, 2401,
94 5681, 7880, 10207, 10021, 9587, 8091, 6534, 3625,
95 6355, 10207, 11363, 10619, 9700, 8935, 6155, 3507,
96 6623, 9186, 10226, 9557, 8730, 8041, 6028, 3322,
97 5632, 9232, 9031, 8730, 8192, 7040, 5542, 3390,
98 5230, 7533, 7621, 7568, 7040, 6321, 5225, 3219,
99 3602, 5189, 5250, 5539, 5265, 5007, 4199, 2638,
100 1907, 2841, 3230, 3156, 3249, 3108, 2638, 1617
104 /*****************************************************************************
105 * pi_default_nonintra_quant : default quantization matrix
106 *****************************************************************************/
108 int pi_default_nonintra_quant[] =
110 16, 16, 16, 16, 16, 16, 16, 16,
111 16, 16, 16, 16, 16, 16, 16, 16,
112 16, 16, 16, 16, 16, 16, 16, 16,
113 16, 16, 16, 16, 16, 16, 16, 16,
114 16, 16, 16, 16, 16, 16, 16, 16,
115 16, 16, 16, 16, 16, 16, 16, 16,
116 16, 16, 16, 16, 16, 16, 16, 16,
117 16, 16, 16, 16, 16, 16, 16, 16
120 int pi_default_nonintra_quanit[] =
122 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
123 5680, 7888, 7424, 6688, 5680, 4464, 3072, 1568,
124 5344, 7424, 6992, 6288, 5344, 4208, 2896, 1472,
125 4816, 6688, 6288, 5664, 4816, 3792, 2608, 1328,
126 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
127 3216, 4464, 4208, 3792, 3216, 2528, 1744, 880,
128 2224, 3072, 2896, 2608, 2224, 1744, 1200, 608,
129 1136, 1568, 1472, 1328, 1136, 880, 608, 304
133 /*****************************************************************************
134 * pi_scan : zig-zag and alternate scan patterns
135 *****************************************************************************/
138 { /* Zig-Zag pattern */
139 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
140 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
141 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
142 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
144 { /* Alternate scan pattern */
145 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
146 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
147 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
148 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
153 * Local inline functions.
156 /*****************************************************************************
157 * ReferenceUpdate : Update the reference pointers when we have a new picture
158 *****************************************************************************/
159 static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
161 picture_t * p_newref )
163 if( i_coding_type != B_CODING_TYPE )
165 if( p_vpar->sequence.p_forward != NULL )
166 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
167 if( p_vpar->sequence.p_backward != NULL )
170 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
171 vpar_SynchroDate( p_vpar ) );
174 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
175 vpar_SynchroDate( p_vpar ) );
179 date = vpar_SynchroDate( p_vpar );
180 vout_DatePicture( p_vpar->p_vout, p_vpar->sequence.p_backward,
182 if( p_vpar->synchro.i_coding_type == I_CODING_TYPE )
183 vpar_SynchroKludge( p_vpar, date );
186 p_vpar->sequence.p_forward = p_vpar->sequence.p_backward;
187 p_vpar->sequence.p_backward = p_newref;
188 if( p_newref != NULL )
189 vout_LinkPicture( p_vpar->p_vout, p_newref );
191 p_vpar->synchro.i_coding_type = i_coding_type;
194 else if( p_newref != NULL )
196 /* Put date immediately. */
197 vout_DatePicture( p_vpar->p_vout, p_newref, vpar_SynchroDate(p_vpar) );
201 /*****************************************************************************
202 * ReferenceReplace : Replace the last reference pointer when we destroy
204 *****************************************************************************/
205 static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
207 picture_t * p_newref )
209 if( i_coding_type != B_CODING_TYPE )
211 if( p_vpar->sequence.p_backward != NULL )
212 vout_UnlinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
213 p_vpar->sequence.p_backward = p_newref;
214 if( p_newref != NULL )
215 vout_LinkPicture( p_vpar->p_vout, p_newref );
219 /*****************************************************************************
220 * LoadMatrix : Load a quantization matrix
221 *****************************************************************************/
222 static __inline__ void LoadMatrix( vpar_thread_t * p_vpar, quant_matrix_t * p_matrix )
226 if( !p_matrix->b_allocated )
228 /* Allocate a piece of memory to load the matrix. */
229 if( (p_matrix->pi_matrix = (int *)malloc( 64*sizeof(int) )) == NULL )
231 intf_ErrMsg( "vpar error: allocation error in LoadMatrix()\n" );
235 p_matrix->b_allocated = 1;
238 for( i_dummy = 0; i_dummy < 64; i_dummy++ )
240 p_matrix->pi_matrix[pi_scan[SCAN_ZIGZAG][i_dummy]]
241 = GetBits( &p_vpar->bit_stream, 8 );
245 /* Discrete Fourier Transform requires the quantization matrices to
246 * be normalized before using them. */
247 vdec_NormQuantMatrix( p_matrix->pi_matrix );
251 /*****************************************************************************
252 * LinkMatrix : Link a quantization matrix to another
253 *****************************************************************************/
254 static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, int * pi_array )
256 if( p_matrix->b_allocated )
258 /* Deallocate the piece of memory. */
259 free( p_matrix->pi_matrix );
260 p_matrix->b_allocated = 0;
263 p_matrix->pi_matrix = pi_array;
267 * Exported functions.
270 /*****************************************************************************
271 * vpar_NextSequenceHeader : Find the next sequence header
272 *****************************************************************************/
273 int vpar_NextSequenceHeader( vpar_thread_t * p_vpar )
275 while( !p_vpar->b_die )
277 NextStartCode( p_vpar );
278 if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE )
280 RemoveBits( &p_vpar->bit_stream, 8 );
285 /*****************************************************************************
286 * vpar_ParseHeader : Parse the next header
287 *****************************************************************************/
288 int vpar_ParseHeader( vpar_thread_t * p_vpar )
290 while( !p_vpar->b_die )
292 NextStartCode( p_vpar );
293 switch( GetBits32( &p_vpar->bit_stream ) )
295 case SEQUENCE_HEADER_CODE:
296 SequenceHeader( p_vpar );
300 case GROUP_START_CODE:
301 GroupHeader( p_vpar );
305 case PICTURE_START_CODE:
306 PictureHeader( p_vpar );
310 case SEQUENCE_END_CODE:
311 intf_DbgMsg("vpar debug: sequence end code received\n");
323 * Following functions are local
326 /*****************************************************************************
327 * SequenceHeader : Parse the next sequence header
328 *****************************************************************************/
329 static void SequenceHeader( vpar_thread_t * p_vpar )
332 static int i_frame_rate_table[16] =
343 RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
347 int i_height_save, i_width_save;
349 i_height_save = p_vpar->sequence.i_height;
350 i_width_save = p_vpar->sequence.i_width;
352 p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
353 p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
354 p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
355 p_vpar->sequence.i_frame_rate =
356 i_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];
358 /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
359 * constrained_parameters_flag */
360 RemoveBits( &p_vpar->bit_stream, 30 );
363 * Quantization matrices
365 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
367 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
371 /* Use default matrix. */
372 LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
375 if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
377 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
381 /* Use default matrix. */
382 LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
385 /* Unless later overwritten by a matrix extension, we have the same
386 * matrices for luminance and chrominance. */
387 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
388 p_vpar->sequence.intra_quant.pi_matrix );
389 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
390 p_vpar->sequence.nonintra_quant.pi_matrix );
395 NextStartCode( p_vpar );
396 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
400 /* Turn the MPEG2 flag on */
401 p_vpar->sequence.b_mpeg2 = 1;
403 /* Parse sequence_extension */
404 RemoveBits32( &p_vpar->bit_stream );
405 /* extension_start_code_identifier, profile_and_level_indication */
406 RemoveBits( &p_vpar->bit_stream, 12 );
407 p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
408 p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
409 p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
410 p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
411 /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
412 RemoveBits( &p_vpar->bit_stream, 22 );
413 /* frame_rate_extension_n */
414 i_dummy = GetBits( &p_vpar->bit_stream, 2 );
415 /* frame_rate_extension_d */
416 p_vpar->sequence.i_frame_rate *= (i_dummy + 1)
417 / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
421 /* It's an MPEG-1 stream. Put adequate parameters. */
423 p_vpar->sequence.b_mpeg2 = 0;
424 p_vpar->sequence.b_progressive = 1;
425 p_vpar->sequence.i_chroma_format = CHROMA_420;
429 p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
430 p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
431 (p_vpar->sequence.i_height + 15) / 16 :
432 2 * ((p_vpar->sequence.i_height + 31) / 32);
433 p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
434 * p_vpar->sequence.i_mb_height;
435 p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
436 p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
437 p_vpar->sequence.i_size = p_vpar->sequence.i_width
438 * p_vpar->sequence.i_height;
440 /* Update chromatic information. */
441 switch( p_vpar->sequence.i_chroma_format )
444 p_vpar->sequence.i_chroma_nb_blocks = 2;
445 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
446 p_vpar->sequence.i_chroma_mb_width = 8;
447 p_vpar->sequence.i_chroma_mb_height = 8;
451 p_vpar->sequence.i_chroma_nb_blocks = 4;
452 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
453 p_vpar->sequence.i_chroma_mb_width = 8;
454 p_vpar->sequence.i_chroma_mb_height = 16;
458 p_vpar->sequence.i_chroma_nb_blocks = 8;
459 p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
460 p_vpar->sequence.i_chroma_mb_width = 16;
461 p_vpar->sequence.i_chroma_mb_height = 16;
464 /* Reset scalable_mode. */
465 p_vpar->sequence.i_scalable_mode = SC_NONE;
468 if( p_vpar->sequence.i_width != i_width_save
469 || p_vpar->sequence.i_height != i_height_save )
471 /* FIXME: What do we do in case of a size change ?? */
475 /* Extension and User data */
476 ExtensionAndUserData( p_vpar );
479 /*****************************************************************************
480 * GroupHeader : Parse the next group of pictures header
481 *****************************************************************************/
482 static void GroupHeader( vpar_thread_t * p_vpar )
484 /* Nothing to do, we don't care. */
485 RemoveBits( &p_vpar->bit_stream, 27 );
486 ExtensionAndUserData( p_vpar );
489 /*****************************************************************************
490 * PictureHeader : Parse the next picture header
491 *****************************************************************************/
492 static void PictureHeader( vpar_thread_t * p_vpar )
496 boolean_t b_parsable;
501 RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
502 p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
503 RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */
505 if( p_vpar->picture.i_coding_type == P_CODING_TYPE
506 || p_vpar->picture.i_coding_type == B_CODING_TYPE )
508 p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
509 p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
511 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
513 p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
514 p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
517 /* extra_information_picture */
518 while( GetBits( &p_vpar->bit_stream, 1 ) )
520 RemoveBits( &p_vpar->bit_stream, 8 );
524 * Picture Coding Extension
526 NextStartCode( p_vpar );
527 if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
529 /* Parse picture_coding_extension */
530 RemoveBits32( &p_vpar->bit_stream );
531 /* extension_start_code_identifier */
532 RemoveBits( &p_vpar->bit_stream, 4 );
534 p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
535 p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
536 p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
537 p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
538 p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
539 i_structure = GetBits( &p_vpar->bit_stream, 2 );
540 p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
541 p_vpar->picture.b_frame_pred_frame_dct
542 = GetBits( &p_vpar->bit_stream, 1 );
543 p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
544 p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
545 p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
546 p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
547 p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
548 /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
549 * the length of the picture_display_extension structure.
550 * chroma_420_type (obsolete) */
551 RemoveBits( &p_vpar->bit_stream, 1 );
552 p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );
554 /* composite_display_flag */
555 if( GetBits( &p_vpar->bit_stream, 1 ) )
557 /* v_axis, field_sequence, sub_carrier, burst_amplitude,
558 * sub_carrier_phase */
559 RemoveBits( &p_vpar->bit_stream, 20 );
564 /* MPEG-1 compatibility flags */
565 p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
566 i_structure = FRAME_STRUCTURE;
567 p_vpar->picture.b_frame_pred_frame_dct = 1;
568 p_vpar->picture.b_concealment_mv = 0;
569 p_vpar->picture.b_q_scale_type = 0;
570 p_vpar->picture.b_intra_vlc_format = 0;
571 p_vpar->picture.b_alternate_scan = 0; /* zigzag */
572 p_vpar->picture.b_repeat_first_field = 0;
573 p_vpar->picture.b_progressive_frame = 1;
576 if( p_vpar->picture.i_current_structure &&
577 (i_structure == FRAME_STRUCTURE ||
578 i_structure == p_vpar->picture.i_current_structure) )
580 /* We don't have the second field of the buffered frame. */
581 if( p_vpar->picture.p_picture != NULL )
583 ReferenceReplace( p_vpar,
584 p_vpar->picture.i_coding_type,
588 for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
590 vpar_DestroyMacroblock( &p_vpar->vfifo,
591 p_vpar->picture.pp_mb[i_mb] );
594 vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
597 p_vpar->picture.i_current_structure = 0;
599 intf_DbgMsg("vpar debug: odd number of field picture.\n");
602 /* Do we have the reference pictures ? */
603 b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
604 (p_vpar->sequence.p_backward == NULL)) ||
605 /* p_backward will become p_forward later */
606 ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
607 (p_vpar->sequence.p_forward == NULL ||
608 p_vpar->sequence.p_backward == NULL)));
612 if( p_vpar->picture.i_current_structure )
614 /* Second field of a frame. We will decode it if, and only if we
615 * have decoded the first field. */
616 b_parsable = (p_vpar->picture.p_picture != NULL);
620 /* Does synchro say we have enough time to decode it ? */
621 b_parsable = vpar_SynchroChoose( p_vpar,
622 p_vpar->picture.i_coding_type, i_structure );
626 else if( !p_vpar->picture.i_current_structure )
628 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
634 /* Update the reference pointers. */
635 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, NULL );
636 #ifndef POLUX_SYNCHRO
637 /* Warn Synchro we have trashed a picture. */
638 vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
640 /* Update context. */
641 if( i_structure != FRAME_STRUCTURE )
642 p_vpar->picture.i_current_structure = i_structure;
643 p_vpar->picture.p_picture = NULL;
648 /* OK, now we are sure we will decode the picture. */
649 #define P_picture p_vpar->picture.p_picture
650 p_vpar->picture.b_error = 0;
651 p_vpar->picture.b_frame_structure = (i_structure == FRAME_STRUCTURE);
653 if( !p_vpar->picture.i_current_structure )
655 /* This is a new frame. Get a structure from the video_output. */
656 while( ( P_picture = vout_CreatePicture( p_vpar->p_vout,
657 99+p_vpar->sequence.i_chroma_format, /*XXX??*/
658 p_vpar->sequence.i_width,
659 p_vpar->sequence.i_height ) )
662 intf_DbgMsg("vpar debug: allocation error in vout_CreatePicture, delaying\n");
663 if( p_vpar->b_die || p_vpar->b_error )
667 msleep( VPAR_OUTMEM_SLEEP );
670 /* Initialize values. */
671 vpar_SynchroDecode( p_vpar, p_vpar->picture.i_coding_type, i_structure );
672 P_picture->i_aspect_ratio = p_vpar->sequence.i_aspect_ratio;
673 P_picture->i_matrix_coefficients = p_vpar->sequence.i_matrix_coefficients;
674 p_vpar->picture.i_l_stride = ( p_vpar->sequence.i_width
675 << ( 1 - p_vpar->picture.b_frame_structure ) );
676 p_vpar->picture.i_c_stride = ( p_vpar->sequence.i_chroma_width
677 << ( 1 - p_vpar->picture.b_frame_structure ));
679 P_picture->i_deccount = p_vpar->sequence.i_mb_size;
680 vlc_mutex_init( &p_vpar->picture.p_picture->lock_deccount );
682 memset( p_vpar->picture.pp_mb, 0, MAX_MB*sizeof(macroblock_t *) );
684 /* FIXME ! remove asap ?? */
685 //memset( P_picture->p_data, 0, (p_vpar->sequence.i_mb_size*384));
687 /* Update the reference pointers. */
688 ReferenceUpdate( p_vpar, p_vpar->picture.i_coding_type, P_picture );
691 /* Link referenced pictures for the decoder
692 * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */
693 if( p_vpar->picture.i_coding_type == P_CODING_TYPE ||
694 p_vpar->picture.i_coding_type == B_CODING_TYPE )
696 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_forward );
698 if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
700 vout_LinkPicture( p_vpar->p_vout, p_vpar->sequence.p_backward );
704 p_vpar->picture.i_current_structure |= i_structure;
705 p_vpar->picture.i_structure = i_structure;
707 /* Initialize picture data for decoding. */
708 if( i_structure == BOTTOM_FIELD )
710 i_mb_base = p_vpar->sequence.i_mb_size >> 1;
711 p_vpar->mb.i_l_y = 1;
712 p_vpar->mb.i_c_y = 1;
717 p_vpar->mb.i_l_y = p_vpar->mb.i_c_y = 0;
719 p_vpar->mb.i_l_x = p_vpar->mb.i_c_x = 0;
721 /* Extension and User data. */
722 ExtensionAndUserData( p_vpar );
724 vpar_PictureData( p_vpar, i_mb_base );
726 if( p_vpar->b_die || p_vpar->b_error )
731 if( p_vpar->picture.b_error )
734 //fprintf(stderr, "Image trashee\n");
736 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
738 vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
742 if( P_picture->i_deccount != 1 )
744 vout_DestroyPicture( p_vpar->p_vout, P_picture );
747 ReferenceReplace( p_vpar, p_vpar->picture.i_coding_type, NULL );
749 /* Prepare context for the next picture. */
751 if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
752 p_vpar->picture.i_current_structure = 0;
754 else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE )
756 //fprintf(stderr, "Image parsee (%d)\n", p_vpar->picture.i_coding_type);
757 /* Frame completely parsed. */
759 for( i_mb = 1; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
761 vpar_DecodeMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] );
764 /* Send signal to the video_decoder. */
765 vlc_mutex_lock( &p_vpar->vfifo.lock );
766 vlc_cond_signal( &p_vpar->vfifo.wait );
767 vlc_mutex_unlock( &p_vpar->vfifo.lock );
770 /* Prepare context for the next picture. */
772 p_vpar->picture.i_current_structure = 0;
777 /*****************************************************************************
778 * ExtensionAndUserData : Parse the extension_and_user_data structure
779 *****************************************************************************/
780 static void ExtensionAndUserData( vpar_thread_t * p_vpar )
782 while( !p_vpar->b_die )
784 NextStartCode( p_vpar );
785 switch( ShowBits( &p_vpar->bit_stream, 32 ) )
787 case EXTENSION_START_CODE:
788 RemoveBits32( &p_vpar->bit_stream );
789 switch( GetBits( &p_vpar->bit_stream, 4 ) )
791 case SEQUENCE_DISPLAY_EXTENSION_ID:
792 SequenceDisplayExtension( p_vpar );
794 case QUANT_MATRIX_EXTENSION_ID:
795 QuantMatrixExtension( p_vpar );
797 case SEQUENCE_SCALABLE_EXTENSION_ID:
798 SequenceScalableExtension( p_vpar );
800 case PICTURE_DISPLAY_EXTENSION_ID:
801 PictureDisplayExtension( p_vpar );
803 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
804 PictureSpatialScalableExtension( p_vpar );
806 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
807 PictureTemporalScalableExtension( p_vpar );
809 case COPYRIGHT_EXTENSION_ID:
810 CopyrightExtension( p_vpar );
816 case USER_DATA_START_CODE:
817 RemoveBits32( &p_vpar->bit_stream );
818 /* Wait for the next start code */
828 /*****************************************************************************
829 * SequenceDisplayExtension : Parse the sequence_display_extension structure *
830 *****************************************************************************/
832 static void SequenceDisplayExtension( vpar_thread_t * p_vpar )
834 /* We don't care sequence_display_extension. */
836 RemoveBits( &p_vpar->bit_stream, 3 );
837 if( GetBits( &p_vpar->bit_stream, 1 ) )
839 /* Two bytes for color_desciption */
840 RemoveBits( &p_vpar->bit_stream, 16 );
841 p_vpar->sequence.i_matrix_coefficients = GetBits( &p_vpar->bit_stream, 8 );
843 /* display_horizontal and vertical_size and a marker_bit */
844 RemoveBits( &p_vpar->bit_stream, 29 );
848 /*****************************************************************************
849 * QuantMatrixExtension : Load quantization matrices for luminance *
851 *****************************************************************************/
853 static void QuantMatrixExtension( vpar_thread_t * p_vpar )
855 if( GetBits( &p_vpar->bit_stream, 1 ) )
857 /* Load intra_quantiser_matrix for luminance. */
858 LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
862 /* Use the default matrix. */
863 LinkMatrix( &p_vpar->sequence.intra_quant,
864 pi_default_intra_quant );
866 if( GetBits( &p_vpar->bit_stream, 1 ) )
868 /* Load non_intra_quantiser_matrix for luminance. */
869 LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
873 /* Use the default matrix. */
874 LinkMatrix( &p_vpar->sequence.nonintra_quant,
875 pi_default_nonintra_quant );
877 if( GetBits( &p_vpar->bit_stream, 1 ) )
879 /* Load intra_quantiser_matrix for chrominance. */
880 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_intra_quant );
884 /* Link the chrominance intra matrix to the luminance one. */
885 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
886 p_vpar->sequence.intra_quant.pi_matrix );
888 if( GetBits( &p_vpar->bit_stream, 1 ) )
890 /* Load non_intra_quantiser_matrix for chrominance. */
891 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
895 /* Link the chrominance intra matrix to the luminance one. */
896 LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
897 p_vpar->sequence.intra_quant.pi_matrix );
899 if( GetBits( &p_vpar->bit_stream, 1 ) )
901 /* Load non_intra_quantiser_matrix for chrominance. */
902 LoadMatrix( p_vpar, &p_vpar->sequence.chroma_nonintra_quant );
906 /* Link the chrominance nonintra matrix to the luminance one. */
907 LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
908 p_vpar->sequence.nonintra_quant.pi_matrix );
913 /*****************************************************************************
914 * SequenceScalableExtension : Parse the sequence_scalable_extension *
915 * structure to handle scalable coding *
916 *****************************************************************************/
918 static void SequenceScalableExtension( vpar_thread_t * p_vpar )
920 /* We don't care about anything scalable except the scalable mode. */
921 switch( p_vpar->sequence.i_scalable_mode = GetBits( &p_vpar->bit_stream, 2 ) )
922 /* The length of the structure depends on the value of the scalable_mode */
925 RemoveBits32( &p_vpar->bit_stream );
926 RemoveBits( &p_vpar->bit_stream, 21 );
929 RemoveBits( &p_vpar->bit_stream, 12 );
932 RemoveBits( &p_vpar->bit_stream, 4 );
936 /*****************************************************************************
937 * PictureDisplayExtension : Parse the picture_display_extension structure *
938 *****************************************************************************/
940 static void PictureDisplayExtension( vpar_thread_t * p_vpar )
942 /* Number of frame center offset */
944 /* I am not sure it works but it should
945 (fewer tests than shown in ยง6.3.12) */
946 i_nb = p_vpar->sequence.b_progressive ? p_vpar->sequence.b_progressive +
947 p_vpar->picture.b_repeat_first_field +
948 p_vpar->picture.b_top_field_first
949 : ( p_vpar->picture.b_frame_structure + 1 ) +
950 p_vpar->picture.b_repeat_first_field;
951 for( i_dummy = 0; i_dummy < i_nb; i_dummy++ )
953 RemoveBits( &p_vpar->bit_stream, 17 );
954 RemoveBits( &p_vpar->bit_stream, 17 );
959 /*****************************************************************************
960 * PictureSpatialScalableExtension *
961 *****************************************************************************/
963 static void PictureSpatialScalableExtension( vpar_thread_t * p_vpar )
965 /* That's scalable, so we trash it */
966 RemoveBits32( &p_vpar->bit_stream );
967 RemoveBits( &p_vpar->bit_stream, 16 );
971 /*****************************************************************************
972 * PictureTemporalScalableExtension *
973 *****************************************************************************/
975 static void PictureTemporalScalableExtension( vpar_thread_t * p_vpar )
977 /* Scalable again, trashed again */
978 RemoveBits( &p_vpar->bit_stream, 23 );
982 /*****************************************************************************
983 * CopyrightExtension : Keeps some legal informations *
984 *****************************************************************************/
986 static void CopyrightExtension( vpar_thread_t * p_vpar )
988 u32 i_copyright_nb_1, i_copyright_nb_2; /* local integers */
989 p_vpar->sequence.b_copyright_flag = GetBits( &p_vpar->bit_stream, 1 );
990 /* A flag that says whether the copyright information is significant */
991 p_vpar->sequence.i_copyright_id = GetBits( &p_vpar->bit_stream, 8 );
992 /* An identifier compliant with ISO/CEI JTC 1/SC 29 */
993 p_vpar->sequence.b_original = GetBits( &p_vpar->bit_stream, 1 );
995 RemoveBits( &p_vpar->bit_stream, 8 );
996 /* The copyright_number is split in three parts */
998 i_copyright_nb_1 = GetBits( &p_vpar->bit_stream, 20 );
999 RemoveBits( &p_vpar->bit_stream, 1 );
1001 i_copyright_nb_2 = GetBits( &p_vpar->bit_stream, 22 );
1002 RemoveBits( &p_vpar->bit_stream, 1 );
1003 /* third part and sum */
1004 p_vpar->sequence.i_copyright_nb = ( (u64)i_copyright_nb_1 << 44 ) |
1005 ( (u64)i_copyright_nb_2 << 22 ) |
1006 ( (u64)GetBits( &p_vpar->bit_stream, 22 ) );