3 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
4 * Copyright (C) 2003 Regis Duchesne <hpreg@zoy.org>
5 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
7 * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
8 * See http://libmpeg2.sourceforge.net/ for updates.
10 * mpeg2dec 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 * mpeg2dec 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-1307 USA
29 #include <vlc_common.h>
33 #include "xxmc-config.h"
36 #include "attributes.h"
37 #include "mpeg2_internal.h"
40 #define SEQ_DISPLAY_EXT 4
41 #define QUANT_MATRIX_EXT 8
42 #define COPYRIGHT_EXT 0x10
43 #define PIC_DISPLAY_EXT 0x80
44 #define PIC_CODING_EXT 0x100
46 /* default intra quant matrix, in zig-zag order */
47 static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) =
54 27, 27, 27, 26, 26, 26,
55 26, 27, 27, 27, 29, 29, 29,
56 34, 34, 34, 29, 29, 29, 27, 27,
57 29, 29, 32, 32, 34, 34, 37,
58 38, 37, 35, 35, 34, 35,
66 uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) =
68 /* Zig-Zag scan pattern */
69 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
70 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
71 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
72 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
75 uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) =
77 /* Alternate scan pattern */
78 0, 8, 16, 24, 1, 9, 2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
79 41, 33, 26, 18, 3, 11, 4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
80 51, 59, 20, 28, 5, 13, 6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
81 53, 61, 22, 30, 7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
84 void mpeg2_header_state_init( mpeg2dec_t *mpeg2dec )
86 if( mpeg2dec->sequence.width != (unsigned int)-1 )
90 mpeg2dec->sequence.width = (unsigned int)-1;
91 if( !mpeg2dec->custom_fbuf )
93 for( i = mpeg2dec->alloc_index_user;
94 i < mpeg2dec->alloc_index; i++ )
96 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[0] );
97 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[1] );
98 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[2] );
101 if( mpeg2dec->convert_start )
103 for( i = 0; i < 3; i++ )
105 mpeg2_free( mpeg2dec->yuv_buf[i][0] );
106 mpeg2_free( mpeg2dec->yuv_buf[i][1] );
107 mpeg2_free( mpeg2dec->yuv_buf[i][2] );
110 if( mpeg2dec->decoder.convert_id )
111 mpeg2_free( mpeg2dec->decoder.convert_id );
113 mpeg2dec->decoder.coding_type = I_TYPE;
114 mpeg2dec->decoder.convert = NULL;
115 mpeg2dec->decoder.convert_id = NULL;
116 mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
117 mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
118 mpeg2dec->picture = mpeg2dec->pictures;
119 mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf;
120 mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf;
121 mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf;
123 mpeg2dec->alloc_index = 0;
124 mpeg2dec->alloc_index_user = 0;
125 mpeg2dec->first_decode_slice = 1;
126 mpeg2dec->nb_decode_slices = 0xb0 - 1;
127 mpeg2dec->convert = NULL;
128 mpeg2dec->convert_start = NULL;
129 mpeg2dec->custom_fbuf = 0;
130 mpeg2dec->yuv_index = 0;
133 void mpeg2_reset_info( mpeg2_info_t * info )
135 info->current_picture = info->current_picture_2nd = NULL;
136 info->display_picture = info->display_picture_2nd = NULL;
137 info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL;
140 static void info_user_data( mpeg2dec_t * mpeg2dec )
142 if( mpeg2dec->user_data_len )
144 mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
145 mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
149 int mpeg2_header_sequence( mpeg2dec_t * mpeg2dec )
151 uint8_t * buffer = mpeg2dec->chunk_start;
152 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
153 static unsigned int frame_period[16] =
155 0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
156 /* unofficial: xing 15 fps */
158 /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
159 5400000, 2700000, 2250000, 1800000, 0, 0
163 if( (buffer[6] & 0x20) != 0x20 )/* missing marker_bit */
166 i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
167 if( !(sequence->display_width = sequence->picture_width = i >> 12) )
169 if( !(sequence->display_height = sequence->picture_height = i & 0xfff) )
171 sequence->width = (sequence->picture_width + 15) & ~15;
172 sequence->height = (sequence->picture_height + 15) & ~15;
173 sequence->chroma_width = sequence->width >> 1;
174 sequence->chroma_height = sequence->height >> 1;
175 sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE |
176 SEQ_VIDEO_FORMAT_UNSPECIFIED);
177 sequence->aspect_ratio_information = buffer[3] >> 4;
178 sequence->pixel_width = sequence->aspect_ratio_information; /* aspect ratio */
179 sequence->frame_period = frame_period[buffer[3] & 15];
180 sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
181 sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
184 sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
186 mpeg2dec->copy_matrix = 3;
189 for( i = 0; i < 64; i++ )
190 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
191 (buffer[i+7] << 7) | (buffer[i+8] >> 1);
196 for( i = 0; i < 64; i++ )
197 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
198 default_intra_quantizer_matrix[i];
203 for( i = 0; i < 64; i++ )
204 mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =
208 memset( mpeg2dec->new_quantizer_matrix[1], 16, 64 );
210 mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
211 mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
212 sequence->profile_level_id = 0x80;
213 sequence->colour_primaries = 0;
214 sequence->transfer_characteristics = 0;
215 sequence->matrix_coefficients = 0;
217 mpeg2dec->ext_state = SEQ_EXT;
218 mpeg2dec->state = STATE_SEQUENCE;
219 mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0;
220 mpeg2dec->ptr_forward_ref_picture = NULL;
221 mpeg2dec->ptr_backward_ref_picture = NULL;
226 static int sequence_ext( mpeg2dec_t * mpeg2dec )
228 uint8_t * buffer = mpeg2dec->chunk_start;
229 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
232 if( !(buffer[3] & 1) )
235 sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
236 sequence->display_width = sequence->picture_width +=
237 ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
238 sequence->display_height = sequence->picture_height +=
239 (buffer[2] << 7) & 0x3000;
240 sequence->width = (sequence->picture_width + 15) & ~15;
241 sequence->height = (sequence->picture_height + 15) & ~15;
242 flags = sequence->flags | SEQ_FLAG_MPEG2;
243 if( !(buffer[1] & 8) )
245 flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
246 sequence->height = (sequence->height + 31) & ~31;
248 if( buffer[5] & 0x80 )
249 flags |= SEQ_FLAG_LOW_DELAY;
250 sequence->flags = flags;
251 sequence->chroma_width = sequence->width;
252 sequence->chroma_height = sequence->height;
254 switch( buffer[1] & 6 )
256 case 0: /* invalid */
259 sequence->chroma_height >>= 1;
261 sequence->chroma_width >>= 1;
264 sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000;
265 sequence->vbv_buffer_size |= buffer[4] << 21;
266 sequence->frame_period = sequence->frame_period *
267 ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1);
268 mpeg2dec->ext_state = SEQ_DISPLAY_EXT;
272 static int sequence_display_ext( mpeg2dec_t * mpeg2dec )
274 uint8_t * buffer = mpeg2dec->chunk_start;
275 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
278 flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
279 ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
282 flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
283 sequence->colour_primaries = buffer[1];
284 sequence->transfer_characteristics = buffer[2];
285 sequence->matrix_coefficients = buffer[3];
289 if( !(buffer[2] & 2) )/* missing marker_bit */
292 sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
293 sequence->display_height =
294 ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
299 static inline void finalize_sequence( mpeg2_sequence_t * sequence )
304 sequence->byte_rate *= 50;
306 if( sequence->flags & SEQ_FLAG_MPEG2 )
308 switch( sequence->pixel_width )
310 case 1: /* square pixels */
311 sequence->pixel_width = sequence->pixel_height = 1;
313 case 2: /* 4:3 aspect ratio */
314 width = 4; height = 3;
316 case 3: /* 16:9 aspect ratio */
317 width = 16; height = 9;
319 case 4: /* 2.21:1 aspect ratio */
320 width = 221; height = 100;
322 default: /* illegal */
323 sequence->pixel_width = sequence->pixel_height = 0;
326 width *= sequence->display_height;
327 height *= sequence->display_width;
331 if( sequence->byte_rate == 50 * 0x3ffff )
332 sequence->byte_rate = 0; /* mpeg-1 VBR */
334 switch( sequence->pixel_width )
337 case 15: /* illegal */
338 sequence->pixel_width = sequence->pixel_height = 0;
340 case 1: /* square pixels */
341 sequence->pixel_width = sequence->pixel_height = 1;
343 case 3: /* 720x576 16:9 */
344 sequence->pixel_width = 64; sequence->pixel_height = 45;
346 case 6: /* 720x480 16:9 */
347 sequence->pixel_width = 32; sequence->pixel_height = 27;
349 case 12: /* 720*480 4:3 */
350 sequence->pixel_width = 8; sequence->pixel_height = 9;
353 height = 88 * sequence->pixel_width + 1171;
358 sequence->pixel_width = width;
359 sequence->pixel_height = height;
361 { /* find greatest common divisor */
363 width = height % tmp;
366 sequence->pixel_width /= height;
367 sequence->pixel_height /= height;
370 static void copy_matrix( mpeg2dec_t * mpeg2dec, int index )
372 if( memcmp( mpeg2dec->quantizer_matrix[index],
373 mpeg2dec->new_quantizer_matrix[index], 64) )
375 memcpy( mpeg2dec->quantizer_matrix[index],
376 mpeg2dec->new_quantizer_matrix[index], 64);
377 mpeg2dec->scaled[index] = -1;
381 static void finalize_matrix( mpeg2dec_t * mpeg2dec )
383 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
386 for( i = 0; i < 2; i++ )
388 if( mpeg2dec->copy_matrix & (1 << i) )
389 copy_matrix (mpeg2dec, i);
390 if( (mpeg2dec->copy_matrix & (4 << i)) &&
391 memcmp( mpeg2dec->quantizer_matrix[i],
392 mpeg2dec->new_quantizer_matrix[i+2], 64) )
394 copy_matrix (mpeg2dec, i + 2);
395 decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
397 else if( mpeg2dec->copy_matrix & (5 << i) )
398 decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
401 decoder->load_intra_quantizer_matrix = 1;
402 decoder->load_non_intra_quantizer_matrix = 1;
406 static mpeg2_state_t invalid_end_action( mpeg2dec_t * mpeg2dec )
408 mpeg2_reset_info( &(mpeg2dec->info) );
409 mpeg2dec->info.gop = NULL;
410 info_user_data( mpeg2dec );
411 mpeg2_header_state_init( mpeg2dec );
412 mpeg2dec->sequence = mpeg2dec->new_sequence;
413 mpeg2dec->action = mpeg2_seek_header;
414 mpeg2dec->state = STATE_SEQUENCE;
415 return STATE_SEQUENCE;
418 void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
420 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
421 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
423 finalize_sequence (sequence);
424 finalize_matrix (mpeg2dec);
426 decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
427 decoder->progressive_sequence = (sequence->flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE);
428 decoder->aspect_ratio_information = sequence->aspect_ratio_information;
429 decoder->width = sequence->width;
430 decoder->height = sequence->height;
431 decoder->vertical_position_extension = (sequence->picture_height > 2800);
432 decoder->chroma_format = ((sequence->chroma_width == sequence->width) +
433 (sequence->chroma_height == sequence->height));
435 if( mpeg2dec->sequence.width != (unsigned int)-1 )
437 unsigned int new_byte_rate;
440 * According to 6.1.1.6, repeat sequence headers should be
441 * identical to the original. However some DVDs dont respect
442 * that and have different bitrates in the repeat sequence
443 * headers. So we'll ignore that in the comparison and still
444 * consider these as repeat sequence headers.
446 * However, be careful not to alter the current sequence when
447 * returning STATE_INVALID_END.
449 new_byte_rate = sequence->byte_rate;
450 sequence->byte_rate = mpeg2dec->sequence.byte_rate;
451 if( memcmp( &(mpeg2dec->sequence), sequence,
452 sizeof (mpeg2_sequence_t)) )
454 decoder->stride_frame = sequence->width;
455 sequence->byte_rate = new_byte_rate;
456 mpeg2_header_end( mpeg2dec );
457 mpeg2dec->action = invalid_end_action;
458 mpeg2dec->state = STATE_INVALID_END;
461 sequence->byte_rate = new_byte_rate;
462 mpeg2dec->state = STATE_SEQUENCE_REPEATED;
465 decoder->stride_frame = sequence->width;
466 mpeg2dec->sequence = *sequence;
467 mpeg2_reset_info( &(mpeg2dec->info) );
468 mpeg2dec->info.sequence = &(mpeg2dec->sequence);
469 mpeg2dec->info.gop = NULL;
470 info_user_data( mpeg2dec );
473 int mpeg2_header_gop( mpeg2dec_t * mpeg2dec )
475 uint8_t * buffer = mpeg2dec->chunk_start;
476 mpeg2_gop_t * gop = &(mpeg2dec->new_gop);
478 if( ! (buffer[1] & 8) )
480 gop->hours = (buffer[0] >> 2) & 31;
481 gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
482 gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
483 gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
484 gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
485 mpeg2dec->state = STATE_GOP;
489 void mpeg2_header_gop_finalize( mpeg2dec_t * mpeg2dec )
491 mpeg2dec->gop = mpeg2dec->new_gop;
492 mpeg2_reset_info( &(mpeg2dec->info) );
493 mpeg2dec->info.gop = &(mpeg2dec->gop);
494 info_user_data (mpeg2dec);
497 void mpeg2_set_fbuf( mpeg2dec_t * mpeg2dec, int b_type )
501 for( i = 0; i < 3; i++ )
503 if( (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf) &&
504 (mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) )
506 mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf;
507 mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0];
508 if( b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
510 if( b_type || mpeg2dec->convert )
511 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
512 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
519 mpeg2_state_t mpeg2_header_picture_start( mpeg2dec_t * mpeg2dec )
521 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
523 mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
524 STATE_PICTURE : STATE_PICTURE_2ND);
526 picture->tag = picture->tag2 = 0;
527 if( mpeg2dec->num_tags )
529 if( mpeg2dec->bytes_since_tag >= 4 )
531 mpeg2dec->num_tags = 0;
532 picture->tag = mpeg2dec->tag_current;
533 picture->tag2 = mpeg2dec->tag2_current;
534 picture->flags = PIC_FLAG_TAGS;
536 else if( mpeg2dec->num_tags > 1 )
538 mpeg2dec->num_tags = 1;
539 picture->tag = mpeg2dec->tag_previous;
540 picture->tag2 = mpeg2dec->tag2_previous;
541 picture->flags = PIC_FLAG_TAGS;
544 picture->display_offset[0].x = picture->display_offset[1].x =
545 picture->display_offset[2].x = mpeg2dec->display_offset_x;
546 picture->display_offset[0].y = picture->display_offset[1].y =
547 picture->display_offset[2].y = mpeg2dec->display_offset_y;
548 return mpeg2_parse_header (mpeg2dec);
551 int mpeg2_header_picture( mpeg2dec_t * mpeg2dec )
553 uint8_t * buffer = mpeg2dec->chunk_start;
554 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
555 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
558 type = (buffer [1] >> 3) & 7;
559 mpeg2dec->ext_state = PIC_CODING_EXT;
561 picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);
563 picture->flags |= type;
565 if( (type == PIC_FLAG_CODING_TYPE_P) || (type == PIC_FLAG_CODING_TYPE_B) )
567 /* forward_f_code and backward_f_code - used in mpeg1 only */
568 decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
569 decoder->f_motion.f_code[0] =
570 (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
571 decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1;
572 decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
575 /* XXXXXX decode extra_information_picture as well */
576 picture->nb_fields = 2;
578 mpeg2dec->q_scale_type = 0;
579 decoder->intra_dc_precision = 7;
580 decoder->frame_pred_frame_dct = 1;
581 decoder->concealment_motion_vectors = 0;
582 decoder->scan = mpeg2_scan_norm;
583 decoder->picture_structure = FRAME_PICTURE;
584 mpeg2dec->copy_matrix = 0;
588 static int picture_coding_ext( mpeg2dec_t * mpeg2dec )
590 uint8_t * buffer = mpeg2dec->chunk_start;
591 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
592 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
595 /* pre subtract 1 for use later in compute_motion_vector */
596 decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1;
597 decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1;
598 decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1;
599 decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1;
601 flags = picture->flags;
602 decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
603 decoder->picture_structure = buffer[2] & 3;
605 switch (decoder->picture_structure)
608 //flags |= PIC_FLAG_TOP_FIELD_FIRST;
610 picture->nb_fields = 1;
613 if( !(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) )
615 picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
616 flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
619 picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
624 decoder->top_field_first = buffer[3] >> 7;
626 if( decoder->top_field_first )
627 flags |= PIC_FLAG_TOP_FIELD_FIRST;
628 decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
629 decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1;
630 decoder->q_scale_type = (buffer[3] >> 4) & 1;
631 mpeg2dec->q_scale_type = buffer[3] & 16;
632 decoder->intra_vlc_format = (buffer[3] >> 3) & 1;
633 decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm;
634 flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0;
636 if( buffer[4] & 0x40 )
637 flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) &
638 PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
639 picture->flags = flags;
641 mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
645 static int picture_display_ext( mpeg2dec_t * mpeg2dec )
647 uint8_t * buffer = mpeg2dec->chunk_start;
648 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
651 nb_pos = picture->nb_fields;
652 if( mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE )
655 for( i = 0; i < nb_pos; i++ )
659 x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
660 (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
661 y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
662 (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
665 picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
666 picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1;
670 picture->display_offset[i].x = mpeg2dec->display_offset_x;
671 picture->display_offset[i].y = mpeg2dec->display_offset_y;
676 void mpeg2_header_picture_finalize( mpeg2dec_t * mpeg2dec, uint32_t accels )
678 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
679 int old_type_b = (decoder->coding_type == B_TYPE);
680 int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY;
682 finalize_matrix( mpeg2dec );
683 decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;
685 /* move in header_process_picture_header */
686 decoder->second_field = (decoder->picture_structure != FRAME_PICTURE) &&
687 !(decoder->second_field);
689 if( mpeg2dec->state == STATE_PICTURE )
691 mpeg2_picture_t * picture;
692 mpeg2_picture_t * other;
694 /* decoder->second_field = 0; */
696 picture = other = mpeg2dec->pictures;
697 if( old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2) )
701 mpeg2dec->picture = picture;
702 *picture = mpeg2dec->new_picture;
706 mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
707 mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
709 mpeg2dec->fbuf[0] = NULL;
710 mpeg2_reset_info (&(mpeg2dec->info));
711 mpeg2dec->info.current_picture = picture;
712 mpeg2dec->info.display_picture = picture;
714 if( decoder->coding_type != B_TYPE )
720 mpeg2dec->info.display_picture = NULL;
725 mpeg2dec->info.display_picture = other;
726 if (other->nb_fields == 1)
727 mpeg2dec->info.display_picture_2nd = other + 1;
728 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1];
731 if( !low_delay + !mpeg2dec->convert )
732 mpeg2dec->info.discard_fbuf =
733 mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
735 if (mpeg2dec->convert)
737 mpeg2_convert_init_t convert_init;
738 if (!mpeg2dec->convert_start)
742 mpeg2dec->decoder.convert_id =
743 mpeg2_malloc( mpeg2dec->convert_id_size,
744 MPEG2_ALLOC_CONVERT_ID );
745 mpeg2dec->convert( MPEG2_CONVERT_START,
746 mpeg2dec->decoder.convert_id,
747 &(mpeg2dec->sequence),
748 mpeg2dec->convert_stride, accels,
749 mpeg2dec->convert_arg, &convert_init );
750 mpeg2dec->convert_start = convert_init.start;
751 mpeg2dec->decoder.convert = convert_init.copy;
753 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
754 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
755 mpeg2dec->yuv_buf[0][0] =
756 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
757 mpeg2dec->yuv_buf[0][1] =
758 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
759 mpeg2dec->yuv_buf[0][2] =
760 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
761 mpeg2dec->yuv_buf[1][0] =
762 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
763 mpeg2dec->yuv_buf[1][1] =
764 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
765 mpeg2dec->yuv_buf[1][2] =
766 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
767 y_size = decoder->stride_frame * 32;
768 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
769 mpeg2dec->yuv_buf[2][0] =
770 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
771 mpeg2dec->yuv_buf[2][1] =
772 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
773 mpeg2dec->yuv_buf[2][2] =
774 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
776 if (!mpeg2dec->custom_fbuf)
778 while( mpeg2dec->alloc_index < 3 )
782 fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
785 (uint8_t *) mpeg2_malloc( convert_init.buf_size[0],
786 MPEG2_ALLOC_CONVERTED );
788 (uint8_t *) mpeg2_malloc( convert_init.buf_size[1],
789 MPEG2_ALLOC_CONVERTED );
791 (uint8_t *) mpeg2_malloc( convert_init.buf_size[2],
792 MPEG2_ALLOC_CONVERTED );
794 mpeg2_set_fbuf( mpeg2dec, (decoder->coding_type == B_TYPE) );
797 else if( !mpeg2dec->custom_fbuf )
799 while (mpeg2dec->alloc_index < 3)
804 fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
806 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
807 uv_size = y_size >> (2 - decoder->chroma_format);
808 fbuf->buf[0] = (uint8_t *) mpeg2_malloc( y_size,
810 fbuf->buf[1] = (uint8_t *) mpeg2_malloc( uv_size,
812 fbuf->buf[2] = (uint8_t *) mpeg2_malloc( uv_size,
815 mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
820 /* decoder->second_field = 1; */
821 mpeg2dec->picture++; /* second field picture */
822 *(mpeg2dec->picture) = mpeg2dec->new_picture;
823 mpeg2dec->info.current_picture_2nd = mpeg2dec->picture;
824 if (low_delay || decoder->coding_type == B_TYPE)
825 mpeg2dec->info.display_picture_2nd = mpeg2dec->picture;
827 info_user_data( mpeg2dec );
830 static int copyright_ext( mpeg2dec_t * mpeg2dec )
835 static int quant_matrix_ext( mpeg2dec_t * mpeg2dec )
837 uint8_t * buffer = mpeg2dec->chunk_start;
840 for (i = 0; i < 4; i++)
842 if (buffer[0] & (8 >> i))
844 for (j = 0; j < 64; j++)
845 mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] =
846 (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i));
847 mpeg2dec->copy_matrix |= 1 << i;
854 int mpeg2_header_extension( mpeg2dec_t * mpeg2dec )
856 static int (* parser[]) (mpeg2dec_t *) = {
857 0, sequence_ext, sequence_display_ext, quant_matrix_ext,
858 copyright_ext, 0, 0, picture_display_ext, picture_coding_ext
862 ext = mpeg2dec->chunk_start[0] >> 4;
865 if( !(mpeg2dec->ext_state & ext_bit) )
866 return 0; /* ignore illegal extensions */
867 mpeg2dec->ext_state &= ~ext_bit;
868 return parser[ext] (mpeg2dec);
871 int mpeg2_header_user_data( mpeg2dec_t * mpeg2dec )
873 mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
874 mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
878 static void prescale( mpeg2dec_t * mpeg2dec, int index )
880 static int non_linear_scale [] =
882 0, 1, 2, 3, 4, 5, 6, 7,
883 8, 10, 12, 14, 16, 18, 20, 22,
884 24, 28, 32, 36, 40, 44, 48, 52,
885 56, 64, 72, 80, 88, 96, 104, 112
888 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
890 if( mpeg2dec->scaled[index] != mpeg2dec->q_scale_type )
892 mpeg2dec->scaled[index] = mpeg2dec->q_scale_type;
893 for( i = 0; i < 32; i++ )
895 k = mpeg2dec->q_scale_type ? non_linear_scale[i] : (i << 1);
896 for( j = 0; j < 64; j++ )
897 decoder->quantizer_prescale[index][i][j] =
898 k * mpeg2dec->quantizer_matrix[index][j];
903 mpeg2_state_t mpeg2_header_slice_start( mpeg2dec_t * mpeg2dec )
905 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
907 mpeg2dec->info.user_data = NULL;
908 mpeg2dec->info.user_data_len = 0;
909 mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 ||
910 mpeg2dec->state == STATE_PICTURE_2ND) ?
911 STATE_SLICE : STATE_SLICE_1ST);
913 if (mpeg2dec->decoder.coding_type != D_TYPE)
915 prescale (mpeg2dec, 0);
916 if( decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2] )
917 prescale (mpeg2dec, 2);
918 if( mpeg2dec->decoder.coding_type != I_TYPE )
920 prescale (mpeg2dec, 1);
921 if( decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3] )
922 prescale (mpeg2dec, 3);
926 if( !(mpeg2dec->nb_decode_slices) )
927 mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
928 else if( mpeg2dec->convert_start )
930 mpeg2dec->convert_start( decoder->convert_id, mpeg2dec->fbuf[0],
931 mpeg2dec->picture, mpeg2dec->info.gop );
933 if( mpeg2dec->decoder.coding_type == B_TYPE )
934 mpeg2_init_fbuf( &(mpeg2dec->decoder), mpeg2dec->yuv_buf[2],
935 mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
936 mpeg2dec->yuv_buf[mpeg2dec->yuv_index] );
939 mpeg2_init_fbuf( &(mpeg2dec->decoder),
940 mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
941 mpeg2dec->yuv_buf[mpeg2dec->yuv_index],
942 mpeg2dec->yuv_buf[mpeg2dec->yuv_index] );
943 if( mpeg2dec->state == STATE_SLICE )
944 mpeg2dec->yuv_index ^= 1;
951 b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
952 mpeg2_init_fbuf( &(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf,
953 mpeg2dec->fbuf[b_type + 1]->buf,
954 mpeg2dec->fbuf[b_type]->buf );
956 mpeg2dec->action = NULL;
957 return (mpeg2_state_t)-1;
960 static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec)
962 mpeg2_reset_info (&(mpeg2dec->info));
963 mpeg2dec->info.sequence = NULL;
964 mpeg2dec->info.gop = NULL;
965 mpeg2_header_state_init (mpeg2dec);
966 mpeg2dec->action = mpeg2_seek_header;
967 return mpeg2_seek_header (mpeg2dec);
970 mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
972 mpeg2_picture_t * picture;
975 b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
976 picture = mpeg2dec->pictures;
977 if( (mpeg2dec->picture >= picture + 2) ^ b_type )
978 picture = mpeg2dec->pictures + 2;
980 mpeg2_reset_info (&(mpeg2dec->info));
981 if( !(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
983 mpeg2dec->info.display_picture = picture;
984 if( picture->nb_fields == 1 )
985 mpeg2dec->info.display_picture_2nd = picture + 1;
986 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type];
987 if( !mpeg2dec->convert )
988 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1];
990 else if( !mpeg2dec->convert )
991 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
992 mpeg2dec->action = seek_sequence;