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 "xxmc-config.h"
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;
666 picture->display_offset[i].x = mpeg2dec->display_offset_x;
667 picture->display_offset[i].y = mpeg2dec->display_offset_y;
672 void mpeg2_header_picture_finalize( mpeg2dec_t * mpeg2dec, uint32_t accels )
674 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
675 int old_type_b = (decoder->coding_type == B_TYPE);
676 int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY;
678 finalize_matrix( mpeg2dec );
679 decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;
681 /* move in header_process_picture_header */
682 decoder->second_field = (decoder->picture_structure != FRAME_PICTURE) &&
683 !(decoder->second_field);
685 if( mpeg2dec->state == STATE_PICTURE )
687 mpeg2_picture_t * picture;
688 mpeg2_picture_t * other;
690 /* decoder->second_field = 0; */
692 picture = other = mpeg2dec->pictures;
693 if( old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2) )
697 mpeg2dec->picture = picture;
698 *picture = mpeg2dec->new_picture;
702 mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
703 mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
705 mpeg2dec->fbuf[0] = NULL;
706 mpeg2_reset_info (&(mpeg2dec->info));
707 mpeg2dec->info.current_picture = picture;
708 mpeg2dec->info.display_picture = picture;
710 if( decoder->coding_type != B_TYPE )
716 mpeg2dec->info.display_picture = NULL;
721 mpeg2dec->info.display_picture = other;
722 if (other->nb_fields == 1)
723 mpeg2dec->info.display_picture_2nd = other + 1;
724 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1];
727 if( !low_delay + !mpeg2dec->convert )
728 mpeg2dec->info.discard_fbuf =
729 mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
731 if (mpeg2dec->convert)
733 mpeg2_convert_init_t convert_init;
734 if (!mpeg2dec->convert_start)
738 mpeg2dec->decoder.convert_id =
739 mpeg2_malloc( mpeg2dec->convert_id_size,
740 MPEG2_ALLOC_CONVERT_ID );
741 mpeg2dec->convert( MPEG2_CONVERT_START,
742 mpeg2dec->decoder.convert_id,
743 &(mpeg2dec->sequence),
744 mpeg2dec->convert_stride, accels,
745 mpeg2dec->convert_arg, &convert_init );
746 mpeg2dec->convert_start = convert_init.start;
747 mpeg2dec->decoder.convert = convert_init.copy;
749 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
750 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
751 mpeg2dec->yuv_buf[0][0] =
752 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
753 mpeg2dec->yuv_buf[0][1] =
754 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
755 mpeg2dec->yuv_buf[0][2] =
756 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
757 mpeg2dec->yuv_buf[1][0] =
758 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
759 mpeg2dec->yuv_buf[1][1] =
760 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
761 mpeg2dec->yuv_buf[1][2] =
762 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
763 y_size = decoder->stride_frame * 32;
764 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
765 mpeg2dec->yuv_buf[2][0] =
766 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
767 mpeg2dec->yuv_buf[2][1] =
768 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
769 mpeg2dec->yuv_buf[2][2] =
770 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
772 if (!mpeg2dec->custom_fbuf)
774 while( mpeg2dec->alloc_index < 3 )
778 fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
781 (uint8_t *) mpeg2_malloc( convert_init.buf_size[0],
782 MPEG2_ALLOC_CONVERTED );
784 (uint8_t *) mpeg2_malloc( convert_init.buf_size[1],
785 MPEG2_ALLOC_CONVERTED );
787 (uint8_t *) mpeg2_malloc( convert_init.buf_size[2],
788 MPEG2_ALLOC_CONVERTED );
790 mpeg2_set_fbuf( mpeg2dec, (decoder->coding_type == B_TYPE) );
793 else if( !mpeg2dec->custom_fbuf )
795 while (mpeg2dec->alloc_index < 3)
800 fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
802 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
803 uv_size = y_size >> (2 - decoder->chroma_format);
804 fbuf->buf[0] = (uint8_t *) mpeg2_malloc( y_size,
806 fbuf->buf[1] = (uint8_t *) mpeg2_malloc( uv_size,
808 fbuf->buf[2] = (uint8_t *) mpeg2_malloc( uv_size,
811 mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
816 /* decoder->second_field = 1; */
817 mpeg2dec->picture++; /* second field picture */
818 *(mpeg2dec->picture) = mpeg2dec->new_picture;
819 mpeg2dec->info.current_picture_2nd = mpeg2dec->picture;
820 if (low_delay || decoder->coding_type == B_TYPE)
821 mpeg2dec->info.display_picture_2nd = mpeg2dec->picture;
823 info_user_data( mpeg2dec );
826 static int copyright_ext( mpeg2dec_t * mpeg2dec )
831 static int quant_matrix_ext( mpeg2dec_t * mpeg2dec )
833 uint8_t * buffer = mpeg2dec->chunk_start;
836 for (i = 0; i < 4; i++)
838 if (buffer[0] & (8 >> i))
840 for (j = 0; j < 64; j++)
841 mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] =
842 (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i));
843 mpeg2dec->copy_matrix |= 1 << i;
850 int mpeg2_header_extension( mpeg2dec_t * mpeg2dec )
852 static int (* parser[]) (mpeg2dec_t *) = {
853 0, sequence_ext, sequence_display_ext, quant_matrix_ext,
854 copyright_ext, 0, 0, picture_display_ext, picture_coding_ext
858 ext = mpeg2dec->chunk_start[0] >> 4;
861 if( !(mpeg2dec->ext_state & ext_bit) )
862 return 0; /* ignore illegal extensions */
863 mpeg2dec->ext_state &= ~ext_bit;
864 return parser[ext] (mpeg2dec);
867 int mpeg2_header_user_data( mpeg2dec_t * mpeg2dec )
869 mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
870 mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
874 static void prescale( mpeg2dec_t * mpeg2dec, int index )
876 static int non_linear_scale [] =
878 0, 1, 2, 3, 4, 5, 6, 7,
879 8, 10, 12, 14, 16, 18, 20, 22,
880 24, 28, 32, 36, 40, 44, 48, 52,
881 56, 64, 72, 80, 88, 96, 104, 112
884 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
886 if( mpeg2dec->scaled[index] != mpeg2dec->q_scale_type )
888 mpeg2dec->scaled[index] = mpeg2dec->q_scale_type;
889 for( i = 0; i < 32; i++ )
891 k = mpeg2dec->q_scale_type ? non_linear_scale[i] : (i << 1);
892 for( j = 0; j < 64; j++ )
893 decoder->quantizer_prescale[index][i][j] =
894 k * mpeg2dec->quantizer_matrix[index][j];
899 mpeg2_state_t mpeg2_header_slice_start( mpeg2dec_t * mpeg2dec )
901 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
903 mpeg2dec->info.user_data = NULL;
904 mpeg2dec->info.user_data_len = 0;
905 mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 ||
906 mpeg2dec->state == STATE_PICTURE_2ND) ?
907 STATE_SLICE : STATE_SLICE_1ST);
909 if (mpeg2dec->decoder.coding_type != D_TYPE)
911 prescale (mpeg2dec, 0);
912 if( decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2] )
913 prescale (mpeg2dec, 2);
914 if( mpeg2dec->decoder.coding_type != I_TYPE )
916 prescale (mpeg2dec, 1);
917 if( decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3] )
918 prescale (mpeg2dec, 3);
922 if( !(mpeg2dec->nb_decode_slices) )
923 mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
924 else if( mpeg2dec->convert_start )
926 mpeg2dec->convert_start( decoder->convert_id, mpeg2dec->fbuf[0],
927 mpeg2dec->picture, mpeg2dec->info.gop );
929 if( mpeg2dec->decoder.coding_type == B_TYPE )
930 mpeg2_init_fbuf( &(mpeg2dec->decoder), mpeg2dec->yuv_buf[2],
931 mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
932 mpeg2dec->yuv_buf[mpeg2dec->yuv_index] );
935 mpeg2_init_fbuf( &(mpeg2dec->decoder),
936 mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
937 mpeg2dec->yuv_buf[mpeg2dec->yuv_index],
938 mpeg2dec->yuv_buf[mpeg2dec->yuv_index] );
939 if( mpeg2dec->state == STATE_SLICE )
940 mpeg2dec->yuv_index ^= 1;
947 b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
948 mpeg2_init_fbuf( &(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf,
949 mpeg2dec->fbuf[b_type + 1]->buf,
950 mpeg2dec->fbuf[b_type]->buf );
952 mpeg2dec->action = NULL;
953 return (mpeg2_state_t)-1;
956 static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec)
958 mpeg2_reset_info (&(mpeg2dec->info));
959 mpeg2dec->info.sequence = NULL;
960 mpeg2dec->info.gop = NULL;
961 mpeg2_header_state_init (mpeg2dec);
962 mpeg2dec->action = mpeg2_seek_header;
963 return mpeg2_seek_header (mpeg2dec);
966 mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
968 mpeg2_picture_t * picture;
971 b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
972 picture = mpeg2dec->pictures;
973 if( (mpeg2dec->picture >= picture + 2) ^ b_type )
974 picture = mpeg2dec->pictures + 2;
976 mpeg2_reset_info (&(mpeg2dec->info));
977 if( !(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
979 mpeg2dec->info.display_picture = picture;
980 if( picture->nb_fields == 1 )
981 mpeg2dec->info.display_picture_2nd = picture + 1;
982 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type];
983 if( !mpeg2dec->convert )
984 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1];
986 else if( !mpeg2dec->convert )
987 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
988 mpeg2dec->action = seek_sequence;