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
25 #include "xxmc-config.h"
28 #include <stdlib.h> /* defines NULL */
29 #include <string.h> /* memcmp */
32 #include "attributes.h"
33 #include "mpeg2_internal.h"
36 #define SEQ_DISPLAY_EXT 4
37 #define QUANT_MATRIX_EXT 8
38 #define COPYRIGHT_EXT 0x10
39 #define PIC_DISPLAY_EXT 0x80
40 #define PIC_CODING_EXT 0x100
42 /* default intra quant matrix, in zig-zag order */
43 static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) =
50 27, 27, 27, 26, 26, 26,
51 26, 27, 27, 27, 29, 29, 29,
52 34, 34, 34, 29, 29, 29, 27, 27,
53 29, 29, 32, 32, 34, 34, 37,
54 38, 37, 35, 35, 34, 35,
62 uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) =
64 /* Zig-Zag scan pattern */
65 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
66 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
67 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
68 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
71 uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) =
73 /* Alternate scan pattern */
74 0, 8, 16, 24, 1, 9, 2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
75 41, 33, 26, 18, 3, 11, 4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
76 51, 59, 20, 28, 5, 13, 6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
77 53, 61, 22, 30, 7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
80 void mpeg2_header_state_init( mpeg2dec_t *mpeg2dec )
82 if( mpeg2dec->sequence.width != (unsigned int)-1 )
86 mpeg2dec->sequence.width = (unsigned int)-1;
87 if( !mpeg2dec->custom_fbuf )
89 for( i = mpeg2dec->alloc_index_user;
90 i < mpeg2dec->alloc_index; i++ )
92 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[0] );
93 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[1] );
94 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[2] );
97 if( mpeg2dec->convert_start )
99 for( i = 0; i < 3; i++ )
101 mpeg2_free( mpeg2dec->yuv_buf[i][0] );
102 mpeg2_free( mpeg2dec->yuv_buf[i][1] );
103 mpeg2_free( mpeg2dec->yuv_buf[i][2] );
106 if( mpeg2dec->decoder.convert_id )
107 mpeg2_free( mpeg2dec->decoder.convert_id );
109 mpeg2dec->decoder.coding_type = I_TYPE;
110 mpeg2dec->decoder.convert = NULL;
111 mpeg2dec->decoder.convert_id = NULL;
112 mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
113 mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
114 mpeg2dec->picture = mpeg2dec->pictures;
115 mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf;
116 mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf;
117 mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf;
119 mpeg2dec->alloc_index = 0;
120 mpeg2dec->alloc_index_user = 0;
121 mpeg2dec->first_decode_slice = 1;
122 mpeg2dec->nb_decode_slices = 0xb0 - 1;
123 mpeg2dec->convert = NULL;
124 mpeg2dec->convert_start = NULL;
125 mpeg2dec->custom_fbuf = 0;
126 mpeg2dec->yuv_index = 0;
129 void mpeg2_reset_info( mpeg2_info_t * info )
131 info->current_picture = info->current_picture_2nd = NULL;
132 info->display_picture = info->display_picture_2nd = NULL;
133 info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL;
136 static void info_user_data( mpeg2dec_t * mpeg2dec )
138 if( mpeg2dec->user_data_len )
140 mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
141 mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
145 int mpeg2_header_sequence( mpeg2dec_t * mpeg2dec )
147 uint8_t * buffer = mpeg2dec->chunk_start;
148 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
149 static unsigned int frame_period[16] =
151 0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
152 /* unofficial: xing 15 fps */
154 /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
155 5400000, 2700000, 2250000, 1800000, 0, 0
159 if( (buffer[6] & 0x20) != 0x20 )/* missing marker_bit */
162 i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
163 if( !(sequence->display_width = sequence->picture_width = i >> 12) )
165 if( !(sequence->display_height = sequence->picture_height = i & 0xfff) )
167 sequence->width = (sequence->picture_width + 15) & ~15;
168 sequence->height = (sequence->picture_height + 15) & ~15;
169 sequence->chroma_width = sequence->width >> 1;
170 sequence->chroma_height = sequence->height >> 1;
171 sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE |
172 SEQ_VIDEO_FORMAT_UNSPECIFIED);
173 sequence->aspect_ratio_information = buffer[3] >> 4;
174 sequence->pixel_width = sequence->aspect_ratio_information; /* aspect ratio */
175 sequence->frame_period = frame_period[buffer[3] & 15];
176 sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
177 sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
180 sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
182 mpeg2dec->copy_matrix = 3;
185 for( i = 0; i < 64; i++ )
186 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
187 (buffer[i+7] << 7) | (buffer[i+8] >> 1);
192 for( i = 0; i < 64; i++ )
193 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
194 default_intra_quantizer_matrix[i];
199 for( i = 0; i < 64; i++ )
200 mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =
204 memset( mpeg2dec->new_quantizer_matrix[1], 16, 64 );
206 mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
207 mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
208 sequence->profile_level_id = 0x80;
209 sequence->colour_primaries = 0;
210 sequence->transfer_characteristics = 0;
211 sequence->matrix_coefficients = 0;
213 mpeg2dec->ext_state = SEQ_EXT;
214 mpeg2dec->state = STATE_SEQUENCE;
215 mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0;
216 mpeg2dec->ptr_forward_ref_picture = NULL;
217 mpeg2dec->ptr_backward_ref_picture = NULL;
222 static int sequence_ext( mpeg2dec_t * mpeg2dec )
224 uint8_t * buffer = mpeg2dec->chunk_start;
225 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
228 if( !(buffer[3] & 1) )
231 sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
232 sequence->display_width = sequence->picture_width +=
233 ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
234 sequence->display_height = sequence->picture_height +=
235 (buffer[2] << 7) & 0x3000;
236 sequence->width = (sequence->picture_width + 15) & ~15;
237 sequence->height = (sequence->picture_height + 15) & ~15;
238 flags = sequence->flags | SEQ_FLAG_MPEG2;
239 if( !(buffer[1] & 8) )
241 flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
242 sequence->height = (sequence->height + 31) & ~31;
244 if( buffer[5] & 0x80 )
245 flags |= SEQ_FLAG_LOW_DELAY;
246 sequence->flags = flags;
247 sequence->chroma_width = sequence->width;
248 sequence->chroma_height = sequence->height;
250 switch( buffer[1] & 6 )
252 case 0: /* invalid */
255 sequence->chroma_height >>= 1;
257 sequence->chroma_width >>= 1;
260 sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000;
261 sequence->vbv_buffer_size |= buffer[4] << 21;
262 sequence->frame_period = sequence->frame_period *
263 ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1);
264 mpeg2dec->ext_state = SEQ_DISPLAY_EXT;
268 static int sequence_display_ext( mpeg2dec_t * mpeg2dec )
270 uint8_t * buffer = mpeg2dec->chunk_start;
271 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
274 flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
275 ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
278 flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
279 sequence->colour_primaries = buffer[1];
280 sequence->transfer_characteristics = buffer[2];
281 sequence->matrix_coefficients = buffer[3];
285 if( !(buffer[2] & 2) )/* missing marker_bit */
288 sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
289 sequence->display_height =
290 ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
295 static inline void finalize_sequence( mpeg2_sequence_t * sequence )
300 sequence->byte_rate *= 50;
302 if( sequence->flags & SEQ_FLAG_MPEG2 )
304 switch( sequence->pixel_width )
306 case 1: /* square pixels */
307 sequence->pixel_width = sequence->pixel_height = 1;
309 case 2: /* 4:3 aspect ratio */
310 width = 4; height = 3;
312 case 3: /* 16:9 aspect ratio */
313 width = 16; height = 9;
315 case 4: /* 2.21:1 aspect ratio */
316 width = 221; height = 100;
318 default: /* illegal */
319 sequence->pixel_width = sequence->pixel_height = 0;
322 width *= sequence->display_height;
323 height *= sequence->display_width;
327 if( sequence->byte_rate == 50 * 0x3ffff )
328 sequence->byte_rate = 0; /* mpeg-1 VBR */
330 switch( sequence->pixel_width )
333 case 15: /* illegal */
334 sequence->pixel_width = sequence->pixel_height = 0;
336 case 1: /* square pixels */
337 sequence->pixel_width = sequence->pixel_height = 1;
339 case 3: /* 720x576 16:9 */
340 sequence->pixel_width = 64; sequence->pixel_height = 45;
342 case 6: /* 720x480 16:9 */
343 sequence->pixel_width = 32; sequence->pixel_height = 27;
345 case 12: /* 720*480 4:3 */
346 sequence->pixel_width = 8; sequence->pixel_height = 9;
349 height = 88 * sequence->pixel_width + 1171;
354 sequence->pixel_width = width;
355 sequence->pixel_height = height;
357 { /* find greatest common divisor */
359 width = height % tmp;
362 sequence->pixel_width /= height;
363 sequence->pixel_height /= height;
366 static void copy_matrix( mpeg2dec_t * mpeg2dec, int index )
368 if( memcmp( mpeg2dec->quantizer_matrix[index],
369 mpeg2dec->new_quantizer_matrix[index], 64) )
371 memcpy( mpeg2dec->quantizer_matrix[index],
372 mpeg2dec->new_quantizer_matrix[index], 64);
373 mpeg2dec->scaled[index] = -1;
377 static void finalize_matrix( mpeg2dec_t * mpeg2dec )
379 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
382 for( i = 0; i < 2; i++ )
384 if( mpeg2dec->copy_matrix & (1 << i) )
385 copy_matrix (mpeg2dec, i);
386 if( (mpeg2dec->copy_matrix & (4 << i)) &&
387 memcmp( mpeg2dec->quantizer_matrix[i],
388 mpeg2dec->new_quantizer_matrix[i+2], 64) )
390 copy_matrix (mpeg2dec, i + 2);
391 decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
393 else if( mpeg2dec->copy_matrix & (5 << i) )
394 decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
397 decoder->load_intra_quantizer_matrix = 1;
398 decoder->load_non_intra_quantizer_matrix = 1;
402 static mpeg2_state_t invalid_end_action( mpeg2dec_t * mpeg2dec )
404 mpeg2_reset_info( &(mpeg2dec->info) );
405 mpeg2dec->info.gop = NULL;
406 info_user_data( mpeg2dec );
407 mpeg2_header_state_init( mpeg2dec );
408 mpeg2dec->sequence = mpeg2dec->new_sequence;
409 mpeg2dec->action = mpeg2_seek_header;
410 mpeg2dec->state = STATE_SEQUENCE;
411 return STATE_SEQUENCE;
414 void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
416 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
417 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
419 finalize_sequence (sequence);
420 finalize_matrix (mpeg2dec);
422 decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
423 decoder->progressive_sequence = (sequence->flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE);
424 decoder->aspect_ratio_information = sequence->aspect_ratio_information;
425 decoder->width = sequence->width;
426 decoder->height = sequence->height;
427 decoder->vertical_position_extension = (sequence->picture_height > 2800);
428 decoder->chroma_format = ((sequence->chroma_width == sequence->width) +
429 (sequence->chroma_height == sequence->height));
431 if( mpeg2dec->sequence.width != (unsigned int)-1 )
433 unsigned int new_byte_rate;
436 * According to 6.1.1.6, repeat sequence headers should be
437 * identical to the original. However some DVDs dont respect
438 * that and have different bitrates in the repeat sequence
439 * headers. So we'll ignore that in the comparison and still
440 * consider these as repeat sequence headers.
442 * However, be careful not to alter the current sequence when
443 * returning STATE_INVALID_END.
445 new_byte_rate = sequence->byte_rate;
446 sequence->byte_rate = mpeg2dec->sequence.byte_rate;
447 if( memcmp( &(mpeg2dec->sequence), sequence,
448 sizeof (mpeg2_sequence_t)) )
450 decoder->stride_frame = sequence->width;
451 sequence->byte_rate = new_byte_rate;
452 mpeg2_header_end( mpeg2dec );
453 mpeg2dec->action = invalid_end_action;
454 mpeg2dec->state = STATE_INVALID_END;
457 sequence->byte_rate = new_byte_rate;
458 mpeg2dec->state = STATE_SEQUENCE_REPEATED;
461 decoder->stride_frame = sequence->width;
462 mpeg2dec->sequence = *sequence;
463 mpeg2_reset_info( &(mpeg2dec->info) );
464 mpeg2dec->info.sequence = &(mpeg2dec->sequence);
465 mpeg2dec->info.gop = NULL;
466 info_user_data( mpeg2dec );
469 int mpeg2_header_gop( mpeg2dec_t * mpeg2dec )
471 uint8_t * buffer = mpeg2dec->chunk_start;
472 mpeg2_gop_t * gop = &(mpeg2dec->new_gop);
474 if( ! (buffer[1] & 8) )
476 gop->hours = (buffer[0] >> 2) & 31;
477 gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
478 gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
479 gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
480 gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
481 mpeg2dec->state = STATE_GOP;
485 void mpeg2_header_gop_finalize( mpeg2dec_t * mpeg2dec )
487 mpeg2dec->gop = mpeg2dec->new_gop;
488 mpeg2_reset_info( &(mpeg2dec->info) );
489 mpeg2dec->info.gop = &(mpeg2dec->gop);
490 info_user_data (mpeg2dec);
493 void mpeg2_set_fbuf( mpeg2dec_t * mpeg2dec, int b_type )
497 for( i = 0; i < 3; i++ )
499 if( (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf) &&
500 (mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) )
502 mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf;
503 mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0];
504 if( b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
506 if( b_type || mpeg2dec->convert )
507 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
508 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
515 mpeg2_state_t mpeg2_header_picture_start( mpeg2dec_t * mpeg2dec )
517 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
519 mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
520 STATE_PICTURE : STATE_PICTURE_2ND);
522 picture->tag = picture->tag2 = 0;
523 if( mpeg2dec->num_tags )
525 if( mpeg2dec->bytes_since_tag >= 4 )
527 mpeg2dec->num_tags = 0;
528 picture->tag = mpeg2dec->tag_current;
529 picture->tag2 = mpeg2dec->tag2_current;
530 picture->flags = PIC_FLAG_TAGS;
532 else if( mpeg2dec->num_tags > 1 )
534 mpeg2dec->num_tags = 1;
535 picture->tag = mpeg2dec->tag_previous;
536 picture->tag2 = mpeg2dec->tag2_previous;
537 picture->flags = PIC_FLAG_TAGS;
540 picture->display_offset[0].x = picture->display_offset[1].x =
541 picture->display_offset[2].x = mpeg2dec->display_offset_x;
542 picture->display_offset[0].y = picture->display_offset[1].y =
543 picture->display_offset[2].y = mpeg2dec->display_offset_y;
544 return mpeg2_parse_header (mpeg2dec);
547 int mpeg2_header_picture( mpeg2dec_t * mpeg2dec )
549 uint8_t * buffer = mpeg2dec->chunk_start;
550 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
551 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
554 type = (buffer [1] >> 3) & 7;
555 mpeg2dec->ext_state = PIC_CODING_EXT;
557 picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);
559 picture->flags |= type;
561 if( (type == PIC_FLAG_CODING_TYPE_P) || (type == PIC_FLAG_CODING_TYPE_B) )
563 /* forward_f_code and backward_f_code - used in mpeg1 only */
564 decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
565 decoder->f_motion.f_code[0] =
566 (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
567 decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1;
568 decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
571 /* XXXXXX decode extra_information_picture as well */
572 picture->nb_fields = 2;
574 mpeg2dec->q_scale_type = 0;
575 decoder->intra_dc_precision = 7;
576 decoder->frame_pred_frame_dct = 1;
577 decoder->concealment_motion_vectors = 0;
578 decoder->scan = mpeg2_scan_norm;
579 decoder->picture_structure = FRAME_PICTURE;
580 mpeg2dec->copy_matrix = 0;
584 static int picture_coding_ext( mpeg2dec_t * mpeg2dec )
586 uint8_t * buffer = mpeg2dec->chunk_start;
587 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
588 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
591 /* pre subtract 1 for use later in compute_motion_vector */
592 decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1;
593 decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1;
594 decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1;
595 decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1;
597 flags = picture->flags;
598 decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
599 decoder->picture_structure = buffer[2] & 3;
601 switch (decoder->picture_structure)
604 //flags |= PIC_FLAG_TOP_FIELD_FIRST;
606 picture->nb_fields = 1;
609 if( !(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) )
611 picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
612 flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
615 picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
620 decoder->top_field_first = buffer[3] >> 7;
622 if( decoder->top_field_first )
623 flags |= PIC_FLAG_TOP_FIELD_FIRST;
624 decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
625 decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1;
626 decoder->q_scale_type = (buffer[3] >> 4) & 1;
627 mpeg2dec->q_scale_type = buffer[3] & 16;
628 decoder->intra_vlc_format = (buffer[3] >> 3) & 1;
629 decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm;
630 flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0;
632 if( buffer[4] & 0x40 )
633 flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) &
634 PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
635 picture->flags = flags;
637 mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
641 static int picture_display_ext( mpeg2dec_t * mpeg2dec )
643 uint8_t * buffer = mpeg2dec->chunk_start;
644 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
647 nb_pos = picture->nb_fields;
648 if( mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE )
651 for( i = 0; i < nb_pos; i++ )
655 x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
656 (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
657 y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
658 (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
661 picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
662 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;