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
28 #include <string.h> /* memcmp */
30 #include "xxmc-config.h"
33 #include "attributes.h"
34 #include "mpeg2_internal.h"
37 #define SEQ_DISPLAY_EXT 4
38 #define QUANT_MATRIX_EXT 8
39 #define COPYRIGHT_EXT 0x10
40 #define PIC_DISPLAY_EXT 0x80
41 #define PIC_CODING_EXT 0x100
43 /* default intra quant matrix, in zig-zag order */
44 static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) =
51 27, 27, 27, 26, 26, 26,
52 26, 27, 27, 27, 29, 29, 29,
53 34, 34, 34, 29, 29, 29, 27, 27,
54 29, 29, 32, 32, 34, 34, 37,
55 38, 37, 35, 35, 34, 35,
63 uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) =
65 /* Zig-Zag scan pattern */
66 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
67 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
68 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
69 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
72 uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) =
74 /* Alternate scan pattern */
75 0, 8, 16, 24, 1, 9, 2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
76 41, 33, 26, 18, 3, 11, 4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
77 51, 59, 20, 28, 5, 13, 6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
78 53, 61, 22, 30, 7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
81 void mpeg2_header_state_init( mpeg2dec_t *mpeg2dec )
83 if( mpeg2dec->sequence.width != (unsigned int)-1 )
87 mpeg2dec->sequence.width = (unsigned int)-1;
88 if( !mpeg2dec->custom_fbuf )
90 for( i = mpeg2dec->alloc_index_user;
91 i < mpeg2dec->alloc_index; i++ )
93 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[0] );
94 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[1] );
95 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[2] );
98 if( mpeg2dec->convert_start )
100 for( i = 0; i < 3; i++ )
102 mpeg2_free( mpeg2dec->yuv_buf[i][0] );
103 mpeg2_free( mpeg2dec->yuv_buf[i][1] );
104 mpeg2_free( mpeg2dec->yuv_buf[i][2] );
107 if( mpeg2dec->decoder.convert_id )
108 mpeg2_free( mpeg2dec->decoder.convert_id );
110 mpeg2dec->decoder.coding_type = I_TYPE;
111 mpeg2dec->decoder.convert = NULL;
112 mpeg2dec->decoder.convert_id = NULL;
113 mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
114 mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
115 mpeg2dec->picture = mpeg2dec->pictures;
116 mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf;
117 mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf;
118 mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf;
120 mpeg2dec->alloc_index = 0;
121 mpeg2dec->alloc_index_user = 0;
122 mpeg2dec->first_decode_slice = 1;
123 mpeg2dec->nb_decode_slices = 0xb0 - 1;
124 mpeg2dec->convert = NULL;
125 mpeg2dec->convert_start = NULL;
126 mpeg2dec->custom_fbuf = 0;
127 mpeg2dec->yuv_index = 0;
130 void mpeg2_reset_info( mpeg2_info_t * info )
132 info->current_picture = info->current_picture_2nd = NULL;
133 info->display_picture = info->display_picture_2nd = NULL;
134 info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL;
137 static void info_user_data( mpeg2dec_t * mpeg2dec )
139 if( mpeg2dec->user_data_len )
141 mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
142 mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
146 int mpeg2_header_sequence( mpeg2dec_t * mpeg2dec )
148 uint8_t * buffer = mpeg2dec->chunk_start;
149 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
150 static unsigned int frame_period[16] =
152 0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
153 /* unofficial: xing 15 fps */
155 /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
156 5400000, 2700000, 2250000, 1800000, 0, 0
160 if( (buffer[6] & 0x20) != 0x20 )/* missing marker_bit */
163 i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
164 if( !(sequence->display_width = sequence->picture_width = i >> 12) )
166 if( !(sequence->display_height = sequence->picture_height = i & 0xfff) )
168 sequence->width = (sequence->picture_width + 15) & ~15;
169 sequence->height = (sequence->picture_height + 15) & ~15;
170 sequence->chroma_width = sequence->width >> 1;
171 sequence->chroma_height = sequence->height >> 1;
172 sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE |
173 SEQ_VIDEO_FORMAT_UNSPECIFIED);
174 sequence->aspect_ratio_information = buffer[3] >> 4;
175 sequence->pixel_width = sequence->aspect_ratio_information; /* aspect ratio */
176 sequence->frame_period = frame_period[buffer[3] & 15];
177 sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
178 sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
181 sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
183 mpeg2dec->copy_matrix = 3;
186 for( i = 0; i < 64; i++ )
187 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
188 (buffer[i+7] << 7) | (buffer[i+8] >> 1);
193 for( i = 0; i < 64; i++ )
194 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
195 default_intra_quantizer_matrix[i];
200 for( i = 0; i < 64; i++ )
201 mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =
205 memset( mpeg2dec->new_quantizer_matrix[1], 16, 64 );
207 mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
208 mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
209 sequence->profile_level_id = 0x80;
210 sequence->colour_primaries = 0;
211 sequence->transfer_characteristics = 0;
212 sequence->matrix_coefficients = 0;
214 mpeg2dec->ext_state = SEQ_EXT;
215 mpeg2dec->state = STATE_SEQUENCE;
216 mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0;
217 mpeg2dec->ptr_forward_ref_picture = NULL;
218 mpeg2dec->ptr_backward_ref_picture = NULL;
223 static int sequence_ext( mpeg2dec_t * mpeg2dec )
225 uint8_t * buffer = mpeg2dec->chunk_start;
226 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
229 if( !(buffer[3] & 1) )
232 sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
233 sequence->display_width = sequence->picture_width +=
234 ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
235 sequence->display_height = sequence->picture_height +=
236 (buffer[2] << 7) & 0x3000;
237 sequence->width = (sequence->picture_width + 15) & ~15;
238 sequence->height = (sequence->picture_height + 15) & ~15;
239 flags = sequence->flags | SEQ_FLAG_MPEG2;
240 if( !(buffer[1] & 8) )
242 flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
243 sequence->height = (sequence->height + 31) & ~31;
245 if( buffer[5] & 0x80 )
246 flags |= SEQ_FLAG_LOW_DELAY;
247 sequence->flags = flags;
248 sequence->chroma_width = sequence->width;
249 sequence->chroma_height = sequence->height;
251 switch( buffer[1] & 6 )
253 case 0: /* invalid */
256 sequence->chroma_height >>= 1;
258 sequence->chroma_width >>= 1;
261 sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000;
262 sequence->vbv_buffer_size |= buffer[4] << 21;
263 sequence->frame_period = sequence->frame_period *
264 ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1);
265 mpeg2dec->ext_state = SEQ_DISPLAY_EXT;
269 static int sequence_display_ext( mpeg2dec_t * mpeg2dec )
271 uint8_t * buffer = mpeg2dec->chunk_start;
272 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
275 flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
276 ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
279 flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
280 sequence->colour_primaries = buffer[1];
281 sequence->transfer_characteristics = buffer[2];
282 sequence->matrix_coefficients = buffer[3];
286 if( !(buffer[2] & 2) )/* missing marker_bit */
289 sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
290 sequence->display_height =
291 ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
296 static inline void finalize_sequence( mpeg2_sequence_t * sequence )
301 sequence->byte_rate *= 50;
303 if( sequence->flags & SEQ_FLAG_MPEG2 )
305 switch( sequence->pixel_width )
307 case 1: /* square pixels */
308 sequence->pixel_width = sequence->pixel_height = 1;
310 case 2: /* 4:3 aspect ratio */
311 width = 4; height = 3;
313 case 3: /* 16:9 aspect ratio */
314 width = 16; height = 9;
316 case 4: /* 2.21:1 aspect ratio */
317 width = 221; height = 100;
319 default: /* illegal */
320 sequence->pixel_width = sequence->pixel_height = 0;
323 width *= sequence->display_height;
324 height *= sequence->display_width;
328 if( sequence->byte_rate == 50 * 0x3ffff )
329 sequence->byte_rate = 0; /* mpeg-1 VBR */
331 switch( sequence->pixel_width )
334 case 15: /* illegal */
335 sequence->pixel_width = sequence->pixel_height = 0;
337 case 1: /* square pixels */
338 sequence->pixel_width = sequence->pixel_height = 1;
340 case 3: /* 720x576 16:9 */
341 sequence->pixel_width = 64; sequence->pixel_height = 45;
343 case 6: /* 720x480 16:9 */
344 sequence->pixel_width = 32; sequence->pixel_height = 27;
346 case 12: /* 720*480 4:3 */
347 sequence->pixel_width = 8; sequence->pixel_height = 9;
350 height = 88 * sequence->pixel_width + 1171;
355 sequence->pixel_width = width;
356 sequence->pixel_height = height;
358 { /* find greatest common divisor */
360 width = height % tmp;
363 sequence->pixel_width /= height;
364 sequence->pixel_height /= height;
367 static void copy_matrix( mpeg2dec_t * mpeg2dec, int index )
369 if( memcmp( mpeg2dec->quantizer_matrix[index],
370 mpeg2dec->new_quantizer_matrix[index], 64) )
372 memcpy( mpeg2dec->quantizer_matrix[index],
373 mpeg2dec->new_quantizer_matrix[index], 64);
374 mpeg2dec->scaled[index] = -1;
378 static void finalize_matrix( mpeg2dec_t * mpeg2dec )
380 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
383 for( i = 0; i < 2; i++ )
385 if( mpeg2dec->copy_matrix & (1 << i) )
386 copy_matrix (mpeg2dec, i);
387 if( (mpeg2dec->copy_matrix & (4 << i)) &&
388 memcmp( mpeg2dec->quantizer_matrix[i],
389 mpeg2dec->new_quantizer_matrix[i+2], 64) )
391 copy_matrix (mpeg2dec, i + 2);
392 decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
394 else if( mpeg2dec->copy_matrix & (5 << i) )
395 decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
398 decoder->load_intra_quantizer_matrix = 1;
399 decoder->load_non_intra_quantizer_matrix = 1;
403 static mpeg2_state_t invalid_end_action( mpeg2dec_t * mpeg2dec )
405 mpeg2_reset_info( &(mpeg2dec->info) );
406 mpeg2dec->info.gop = NULL;
407 info_user_data( mpeg2dec );
408 mpeg2_header_state_init( mpeg2dec );
409 mpeg2dec->sequence = mpeg2dec->new_sequence;
410 mpeg2dec->action = mpeg2_seek_header;
411 mpeg2dec->state = STATE_SEQUENCE;
412 return STATE_SEQUENCE;
415 void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
417 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
418 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
420 finalize_sequence (sequence);
421 finalize_matrix (mpeg2dec);
423 decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
424 decoder->progressive_sequence = (sequence->flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE);
425 decoder->aspect_ratio_information = sequence->aspect_ratio_information;
426 decoder->width = sequence->width;
427 decoder->height = sequence->height;
428 decoder->vertical_position_extension = (sequence->picture_height > 2800);
429 decoder->chroma_format = ((sequence->chroma_width == sequence->width) +
430 (sequence->chroma_height == sequence->height));
432 if( mpeg2dec->sequence.width != (unsigned int)-1 )
434 unsigned int new_byte_rate;
437 * According to 6.1.1.6, repeat sequence headers should be
438 * identical to the original. However some DVDs dont respect
439 * that and have different bitrates in the repeat sequence
440 * headers. So we'll ignore that in the comparison and still
441 * consider these as repeat sequence headers.
443 * However, be careful not to alter the current sequence when
444 * returning STATE_INVALID_END.
446 new_byte_rate = sequence->byte_rate;
447 sequence->byte_rate = mpeg2dec->sequence.byte_rate;
448 if( memcmp( &(mpeg2dec->sequence), sequence,
449 sizeof (mpeg2_sequence_t)) )
451 decoder->stride_frame = sequence->width;
452 sequence->byte_rate = new_byte_rate;
453 mpeg2_header_end( mpeg2dec );
454 mpeg2dec->action = invalid_end_action;
455 mpeg2dec->state = STATE_INVALID_END;
458 sequence->byte_rate = new_byte_rate;
459 mpeg2dec->state = STATE_SEQUENCE_REPEATED;
462 decoder->stride_frame = sequence->width;
463 mpeg2dec->sequence = *sequence;
464 mpeg2_reset_info( &(mpeg2dec->info) );
465 mpeg2dec->info.sequence = &(mpeg2dec->sequence);
466 mpeg2dec->info.gop = NULL;
467 info_user_data( mpeg2dec );
470 int mpeg2_header_gop( mpeg2dec_t * mpeg2dec )
472 uint8_t * buffer = mpeg2dec->chunk_start;
473 mpeg2_gop_t * gop = &(mpeg2dec->new_gop);
475 if( ! (buffer[1] & 8) )
477 gop->hours = (buffer[0] >> 2) & 31;
478 gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
479 gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
480 gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
481 gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
482 mpeg2dec->state = STATE_GOP;
486 void mpeg2_header_gop_finalize( mpeg2dec_t * mpeg2dec )
488 mpeg2dec->gop = mpeg2dec->new_gop;
489 mpeg2_reset_info( &(mpeg2dec->info) );
490 mpeg2dec->info.gop = &(mpeg2dec->gop);
491 info_user_data (mpeg2dec);
494 void mpeg2_set_fbuf( mpeg2dec_t * mpeg2dec, int b_type )
498 for( i = 0; i < 3; i++ )
500 if( (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf) &&
501 (mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) )
503 mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf;
504 mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0];
505 if( b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
507 if( b_type || mpeg2dec->convert )
508 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
509 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
516 mpeg2_state_t mpeg2_header_picture_start( mpeg2dec_t * mpeg2dec )
518 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
520 mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
521 STATE_PICTURE : STATE_PICTURE_2ND);
523 picture->tag = picture->tag2 = 0;
524 if( mpeg2dec->num_tags )
526 if( mpeg2dec->bytes_since_tag >= 4 )
528 mpeg2dec->num_tags = 0;
529 picture->tag = mpeg2dec->tag_current;
530 picture->tag2 = mpeg2dec->tag2_current;
531 picture->flags = PIC_FLAG_TAGS;
533 else if( mpeg2dec->num_tags > 1 )
535 mpeg2dec->num_tags = 1;
536 picture->tag = mpeg2dec->tag_previous;
537 picture->tag2 = mpeg2dec->tag2_previous;
538 picture->flags = PIC_FLAG_TAGS;
541 picture->display_offset[0].x = picture->display_offset[1].x =
542 picture->display_offset[2].x = mpeg2dec->display_offset_x;
543 picture->display_offset[0].y = picture->display_offset[1].y =
544 picture->display_offset[2].y = mpeg2dec->display_offset_y;
545 return mpeg2_parse_header (mpeg2dec);
548 int mpeg2_header_picture( mpeg2dec_t * mpeg2dec )
550 uint8_t * buffer = mpeg2dec->chunk_start;
551 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
552 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
555 type = (buffer [1] >> 3) & 7;
556 mpeg2dec->ext_state = PIC_CODING_EXT;
558 picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);
560 picture->flags |= type;
562 if( (type == PIC_FLAG_CODING_TYPE_P) || (type == PIC_FLAG_CODING_TYPE_B) )
564 /* forward_f_code and backward_f_code - used in mpeg1 only */
565 decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
566 decoder->f_motion.f_code[0] =
567 (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
568 decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1;
569 decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
572 /* XXXXXX decode extra_information_picture as well */
573 picture->nb_fields = 2;
575 mpeg2dec->q_scale_type = 0;
576 decoder->intra_dc_precision = 7;
577 decoder->frame_pred_frame_dct = 1;
578 decoder->concealment_motion_vectors = 0;
579 decoder->scan = mpeg2_scan_norm;
580 decoder->picture_structure = FRAME_PICTURE;
581 mpeg2dec->copy_matrix = 0;
585 static int picture_coding_ext( mpeg2dec_t * mpeg2dec )
587 uint8_t * buffer = mpeg2dec->chunk_start;
588 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
589 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
592 /* pre subtract 1 for use later in compute_motion_vector */
593 decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1;
594 decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1;
595 decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1;
596 decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1;
598 flags = picture->flags;
599 decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
600 decoder->picture_structure = buffer[2] & 3;
602 switch (decoder->picture_structure)
605 //flags |= PIC_FLAG_TOP_FIELD_FIRST;
607 picture->nb_fields = 1;
610 if( !(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) )
612 picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
613 flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
616 picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
621 decoder->top_field_first = buffer[3] >> 7;
623 if( decoder->top_field_first )
624 flags |= PIC_FLAG_TOP_FIELD_FIRST;
625 decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
626 decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1;
627 decoder->q_scale_type = (buffer[3] >> 4) & 1;
628 mpeg2dec->q_scale_type = buffer[3] & 16;
629 decoder->intra_vlc_format = (buffer[3] >> 3) & 1;
630 decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm;
631 flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0;
633 if( buffer[4] & 0x40 )
634 flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) &
635 PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
636 picture->flags = flags;
638 mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
642 static int picture_display_ext( mpeg2dec_t * mpeg2dec )
644 uint8_t * buffer = mpeg2dec->chunk_start;
645 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
648 nb_pos = picture->nb_fields;
649 if( mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE )
652 for( i = 0; i < nb_pos; i++ )
656 x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
657 (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
658 y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
659 (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
662 picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
663 picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1;
667 picture->display_offset[i].x = mpeg2dec->display_offset_x;
668 picture->display_offset[i].y = mpeg2dec->display_offset_y;
673 void mpeg2_header_picture_finalize( mpeg2dec_t * mpeg2dec, uint32_t accels )
675 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
676 int old_type_b = (decoder->coding_type == B_TYPE);
677 int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY;
679 finalize_matrix( mpeg2dec );
680 decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;
682 /* move in header_process_picture_header */
683 decoder->second_field = (decoder->picture_structure != FRAME_PICTURE) &&
684 !(decoder->second_field);
686 if( mpeg2dec->state == STATE_PICTURE )
688 mpeg2_picture_t * picture;
689 mpeg2_picture_t * other;
691 /* decoder->second_field = 0; */
693 picture = other = mpeg2dec->pictures;
694 if( old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2) )
698 mpeg2dec->picture = picture;
699 *picture = mpeg2dec->new_picture;
703 mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
704 mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
706 mpeg2dec->fbuf[0] = NULL;
707 mpeg2_reset_info (&(mpeg2dec->info));
708 mpeg2dec->info.current_picture = picture;
709 mpeg2dec->info.display_picture = picture;
711 if( decoder->coding_type != B_TYPE )
717 mpeg2dec->info.display_picture = NULL;
722 mpeg2dec->info.display_picture = other;
723 if (other->nb_fields == 1)
724 mpeg2dec->info.display_picture_2nd = other + 1;
725 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1];
728 if( !low_delay + !mpeg2dec->convert )
729 mpeg2dec->info.discard_fbuf =
730 mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
732 if (mpeg2dec->convert)
734 mpeg2_convert_init_t convert_init;
735 if (!mpeg2dec->convert_start)
739 mpeg2dec->decoder.convert_id =
740 mpeg2_malloc( mpeg2dec->convert_id_size,
741 MPEG2_ALLOC_CONVERT_ID );
742 mpeg2dec->convert( MPEG2_CONVERT_START,
743 mpeg2dec->decoder.convert_id,
744 &(mpeg2dec->sequence),
745 mpeg2dec->convert_stride, accels,
746 mpeg2dec->convert_arg, &convert_init );
747 mpeg2dec->convert_start = convert_init.start;
748 mpeg2dec->decoder.convert = convert_init.copy;
750 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
751 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
752 mpeg2dec->yuv_buf[0][0] =
753 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
754 mpeg2dec->yuv_buf[0][1] =
755 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
756 mpeg2dec->yuv_buf[0][2] =
757 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
758 mpeg2dec->yuv_buf[1][0] =
759 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
760 mpeg2dec->yuv_buf[1][1] =
761 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
762 mpeg2dec->yuv_buf[1][2] =
763 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
764 y_size = decoder->stride_frame * 32;
765 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
766 mpeg2dec->yuv_buf[2][0] =
767 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
768 mpeg2dec->yuv_buf[2][1] =
769 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
770 mpeg2dec->yuv_buf[2][2] =
771 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
773 if (!mpeg2dec->custom_fbuf)
775 while( mpeg2dec->alloc_index < 3 )
779 fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
782 (uint8_t *) mpeg2_malloc( convert_init.buf_size[0],
783 MPEG2_ALLOC_CONVERTED );
785 (uint8_t *) mpeg2_malloc( convert_init.buf_size[1],
786 MPEG2_ALLOC_CONVERTED );
788 (uint8_t *) mpeg2_malloc( convert_init.buf_size[2],
789 MPEG2_ALLOC_CONVERTED );
791 mpeg2_set_fbuf( mpeg2dec, (decoder->coding_type == B_TYPE) );
794 else if( !mpeg2dec->custom_fbuf )
796 while (mpeg2dec->alloc_index < 3)
801 fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
803 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
804 uv_size = y_size >> (2 - decoder->chroma_format);
805 fbuf->buf[0] = (uint8_t *) mpeg2_malloc( y_size,
807 fbuf->buf[1] = (uint8_t *) mpeg2_malloc( uv_size,
809 fbuf->buf[2] = (uint8_t *) mpeg2_malloc( uv_size,
812 mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
817 /* decoder->second_field = 1; */
818 mpeg2dec->picture++; /* second field picture */
819 *(mpeg2dec->picture) = mpeg2dec->new_picture;
820 mpeg2dec->info.current_picture_2nd = mpeg2dec->picture;
821 if (low_delay || decoder->coding_type == B_TYPE)
822 mpeg2dec->info.display_picture_2nd = mpeg2dec->picture;
824 info_user_data( mpeg2dec );
827 static int copyright_ext( mpeg2dec_t * mpeg2dec )
832 static int quant_matrix_ext( mpeg2dec_t * mpeg2dec )
834 uint8_t * buffer = mpeg2dec->chunk_start;
837 for (i = 0; i < 4; i++)
839 if (buffer[0] & (8 >> i))
841 for (j = 0; j < 64; j++)
842 mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] =
843 (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i));
844 mpeg2dec->copy_matrix |= 1 << i;
851 int mpeg2_header_extension( mpeg2dec_t * mpeg2dec )
853 static int (* parser[]) (mpeg2dec_t *) = {
854 0, sequence_ext, sequence_display_ext, quant_matrix_ext,
855 copyright_ext, 0, 0, picture_display_ext, picture_coding_ext
859 ext = mpeg2dec->chunk_start[0] >> 4;
862 if( !(mpeg2dec->ext_state & ext_bit) )
863 return 0; /* ignore illegal extensions */
864 mpeg2dec->ext_state &= ~ext_bit;
865 return parser[ext] (mpeg2dec);
868 int mpeg2_header_user_data( mpeg2dec_t * mpeg2dec )
870 mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
871 mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
875 static void prescale( mpeg2dec_t * mpeg2dec, int index )
877 static int non_linear_scale [] =
879 0, 1, 2, 3, 4, 5, 6, 7,
880 8, 10, 12, 14, 16, 18, 20, 22,
881 24, 28, 32, 36, 40, 44, 48, 52,
882 56, 64, 72, 80, 88, 96, 104, 112
885 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
887 if( mpeg2dec->scaled[index] != mpeg2dec->q_scale_type )
889 mpeg2dec->scaled[index] = mpeg2dec->q_scale_type;
890 for( i = 0; i < 32; i++ )
892 k = mpeg2dec->q_scale_type ? non_linear_scale[i] : (i << 1);
893 for( j = 0; j < 64; j++ )
894 decoder->quantizer_prescale[index][i][j] =
895 k * mpeg2dec->quantizer_matrix[index][j];
900 mpeg2_state_t mpeg2_header_slice_start( mpeg2dec_t * mpeg2dec )
902 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
904 mpeg2dec->info.user_data = NULL;
905 mpeg2dec->info.user_data_len = 0;
906 mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 ||
907 mpeg2dec->state == STATE_PICTURE_2ND) ?
908 STATE_SLICE : STATE_SLICE_1ST);
910 if (mpeg2dec->decoder.coding_type != D_TYPE)
912 prescale (mpeg2dec, 0);
913 if( decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2] )
914 prescale (mpeg2dec, 2);
915 if( mpeg2dec->decoder.coding_type != I_TYPE )
917 prescale (mpeg2dec, 1);
918 if( decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3] )
919 prescale (mpeg2dec, 3);
923 if( !(mpeg2dec->nb_decode_slices) )
924 mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
925 else if( mpeg2dec->convert_start )
927 mpeg2dec->convert_start( decoder->convert_id, mpeg2dec->fbuf[0],
928 mpeg2dec->picture, mpeg2dec->info.gop );
930 if( mpeg2dec->decoder.coding_type == B_TYPE )
931 mpeg2_init_fbuf( &(mpeg2dec->decoder), mpeg2dec->yuv_buf[2],
932 mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
933 mpeg2dec->yuv_buf[mpeg2dec->yuv_index] );
936 mpeg2_init_fbuf( &(mpeg2dec->decoder),
937 mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
938 mpeg2dec->yuv_buf[mpeg2dec->yuv_index],
939 mpeg2dec->yuv_buf[mpeg2dec->yuv_index] );
940 if( mpeg2dec->state == STATE_SLICE )
941 mpeg2dec->yuv_index ^= 1;
948 b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
949 mpeg2_init_fbuf( &(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf,
950 mpeg2dec->fbuf[b_type + 1]->buf,
951 mpeg2dec->fbuf[b_type]->buf );
953 mpeg2dec->action = NULL;
954 return (mpeg2_state_t)-1;
957 static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec)
959 mpeg2_reset_info (&(mpeg2dec->info));
960 mpeg2dec->info.sequence = NULL;
961 mpeg2dec->info.gop = NULL;
962 mpeg2_header_state_init (mpeg2dec);
963 mpeg2dec->action = mpeg2_seek_header;
964 return mpeg2_seek_header (mpeg2dec);
967 mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
969 mpeg2_picture_t * picture;
972 b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
973 picture = mpeg2dec->pictures;
974 if( (mpeg2dec->picture >= picture + 2) ^ b_type )
975 picture = mpeg2dec->pictures + 2;
977 mpeg2_reset_info (&(mpeg2dec->info));
978 if( !(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
980 mpeg2dec->info.display_picture = picture;
981 if( picture->nb_fields == 1 )
982 mpeg2dec->info.display_picture_2nd = picture + 1;
983 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type];
984 if( !mpeg2dec->convert )
985 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1];
987 else if( !mpeg2dec->convert )
988 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
989 mpeg2dec->action = seek_sequence;