git.sesse.net Git - vlc/blob - modules/codec/xvmc/header.c

   1 /* $Id$
   2  * header.c
   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>
   6  *
   7  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
   8  * See http://libmpeg2.sourceforge.net/ for updates.
   9  *
  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.
  14  *
  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.
  19  *
  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
  23  */
  24
  25 #include <vlc/vlc.h>
  26
  27 #include <inttypes.h>
  28
  29 #include "xxmc-config.h"
  30
  31 #include "mpeg2.h"
  32 #include "attributes.h"
  33 #include "mpeg2_internal.h"
  34
  35 #define SEQ_EXT 2
  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
  41
  42 /* default intra quant matrix, in zig-zag order */
  43 static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) =
  44 {
  45     8,
  46     16, 16,
  47     19, 16, 19,
  48     22, 22, 22, 22,
  49     22, 22, 26, 24, 26,
  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,
  55     38, 38, 40, 40, 40,
  56     48, 48, 46, 46,
  57     56, 56, 58,
  58     69, 69,
  59     83
  60 };
  61
  62 uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) =
  63 {
  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
  69 };
  70
  71 uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) =
  72 {
  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
  78 };
  79
  80 void mpeg2_header_state_init( mpeg2dec_t *mpeg2dec )
  81 {
  82     if( mpeg2dec->sequence.width != (unsigned int)-1 )
  83     {
  84         int i;
  85
  86         mpeg2dec->sequence.width = (unsigned int)-1;
  87         if( !mpeg2dec->custom_fbuf )
  88         {
  89             for( i = mpeg2dec->alloc_index_user;
  90                  i < mpeg2dec->alloc_index; i++ )
  91             {
  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] );
  95             }
  96         }
  97         if( mpeg2dec->convert_start )
  98         {
  99             for( i = 0; i < 3; i++ )
 100             {
 101                 mpeg2_free( mpeg2dec->yuv_buf[i][0] );
 102                 mpeg2_free( mpeg2dec->yuv_buf[i][1] );
 103                 mpeg2_free( mpeg2dec->yuv_buf[i][2] );
 104             }
 105         }
 106         if( mpeg2dec->decoder.convert_id )
 107             mpeg2_free( mpeg2dec->decoder.convert_id );
 108     }
 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;
 118     mpeg2dec->first = 1;
 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;
 127 }
 128
 129 void mpeg2_reset_info( mpeg2_info_t * info )
 130 {
 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;
 134 }
 135
 136 static void info_user_data( mpeg2dec_t * mpeg2dec )
 137 {
 138     if( mpeg2dec->user_data_len )
 139     {
 140         mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
 141         mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
 142     }
 143 }
 144
 145 int mpeg2_header_sequence( mpeg2dec_t * mpeg2dec )
 146 {
 147     uint8_t * buffer = mpeg2dec->chunk_start;
 148     mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
 149     static unsigned int frame_period[16] =
 150     {
 151         0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
 152         /* unofficial: xing 15 fps */
 153         1800000,
 154         /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
 155         5400000, 2700000, 2250000, 1800000, 0, 0
 156     };
 157     int i;
 158
 159     if( (buffer[6] & 0x20) != 0x20 )/* missing marker_bit */
 160         return 1;
 161
 162     i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
 163     if( !(sequence->display_width = sequence->picture_width = i >> 12) )
 164         return 1;
 165     if( !(sequence->display_height = sequence->picture_height = i & 0xfff) )
 166         return 1;
 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;
 178
 179     if( buffer[7] & 4 )
 180         sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
 181
 182     mpeg2dec->copy_matrix = 3;
 183     if( buffer[7] & 2 )
 184     {
 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);
 188         buffer += 64;
 189     }
 190     else
 191     {
 192         for( i = 0; i < 64; i++ )
 193                 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
 194                                     default_intra_quantizer_matrix[i];
 195     }
 196
 197     if( buffer[7] & 1 )
 198     {
 199         for( i = 0; i < 64; i++ )
 200             mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =
 201                                                          buffer[i+8];
 202     }
 203     else
 204         memset( mpeg2dec->new_quantizer_matrix[1], 16, 64 );
 205
 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;
 212
 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;
 218
 219     return 0;
 220 }
 221
 222 static int sequence_ext( mpeg2dec_t * mpeg2dec )
 223 {
 224     uint8_t * buffer = mpeg2dec->chunk_start;
 225     mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
 226     uint32_t flags;
 227
 228     if( !(buffer[3] & 1) )
 229         return 1;
 230
 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) )
 240     {
 241         flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
 242         sequence->height = (sequence->height + 31) & ~31;
 243     }
 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;
 249
 250     switch( buffer[1] & 6 )
 251     {
 252         case 0:    /* invalid */
 253             return 1;
 254         case 2:    /* 4:2:0 */
 255             sequence->chroma_height >>= 1;
 256         case 4:    /* 4:2:2 */
 257             sequence->chroma_width >>= 1;
 258     }
 259
 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;
 265     return 0;
 266 }
 267
 268 static int sequence_display_ext( mpeg2dec_t * mpeg2dec )
 269 {
 270     uint8_t * buffer = mpeg2dec->chunk_start;
 271     mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
 272     uint32_t flags;
 273
 274     flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
 275             ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
 276     if( buffer[0] & 1 )
 277     {
 278         flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
 279         sequence->colour_primaries = buffer[1];
 280         sequence->transfer_characteristics = buffer[2];
 281         sequence->matrix_coefficients = buffer[3];
 282         buffer += 3;
 283     }
 284
 285     if( !(buffer[2] & 2) )/* missing marker_bit */
 286         return 1;
 287
 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);
 291
 292     return 0;
 293 }
 294
 295 static inline void finalize_sequence( mpeg2_sequence_t * sequence )
 296 {
 297     int width;
 298     int height;
 299
 300     sequence->byte_rate *= 50;
 301
 302     if( sequence->flags & SEQ_FLAG_MPEG2 )
 303     {
 304         switch( sequence->pixel_width )
 305         {
 306             case 1: /* square pixels */
 307                 sequence->pixel_width = sequence->pixel_height = 1;
 308                 return;
 309             case 2: /* 4:3 aspect ratio */
 310                 width = 4; height = 3;
 311                 break;
 312             case 3: /* 16:9 aspect ratio */
 313                 width = 16; height = 9;
 314                 break;
 315             case 4: /* 2.21:1 aspect ratio */
 316                 width = 221; height = 100;
 317                 break;
 318             default: /* illegal */
 319                 sequence->pixel_width = sequence->pixel_height = 0;
 320                 return;
 321         }
 322         width *= sequence->display_height;
 323         height *= sequence->display_width;
 324     }
 325     else
 326     {
 327         if( sequence->byte_rate == 50 * 0x3ffff )
 328             sequence->byte_rate = 0; /* mpeg-1 VBR */
 329
 330         switch( sequence->pixel_width )
 331         {
 332             case 0:
 333             case 15: /* illegal */
 334                 sequence->pixel_width = sequence->pixel_height = 0;
 335                 return;
 336             case 1: /* square pixels */
 337                 sequence->pixel_width = sequence->pixel_height = 1;
 338                 return;
 339             case 3: /* 720x576 16:9 */
 340                 sequence->pixel_width = 64;    sequence->pixel_height = 45;
 341                 return;
 342             case 6: /* 720x480 16:9 */
 343                 sequence->pixel_width = 32;    sequence->pixel_height = 27;
 344                 return;
 345             case 12: /* 720*480 4:3 */
 346                 sequence->pixel_width = 8;    sequence->pixel_height = 9;
 347                 return;
 348             default:
 349                 height = 88 * sequence->pixel_width + 1171;
 350                 width = 2000;
 351         }
 352    }
 353
 354     sequence->pixel_width = width;
 355     sequence->pixel_height = height;
 356     while (width)
 357     { /* find greatest common divisor */
 358         int tmp = width;
 359         width = height % tmp;
 360         height = tmp;
 361     }
 362     sequence->pixel_width /= height;
 363     sequence->pixel_height /= height;
 364 }
 365
 366 static void copy_matrix( mpeg2dec_t * mpeg2dec, int index )
 367 {
 368     if( memcmp( mpeg2dec->quantizer_matrix[index],
 369                 mpeg2dec->new_quantizer_matrix[index], 64) )
 370     {
 371         memcpy( mpeg2dec->quantizer_matrix[index],
 372                 mpeg2dec->new_quantizer_matrix[index], 64);
 373         mpeg2dec->scaled[index] = -1;
 374     }
 375 }
 376
 377 static void finalize_matrix( mpeg2dec_t * mpeg2dec )
 378 {
 379     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 380     int i;
 381
 382     for( i = 0; i < 2; i++ )
 383     {
 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) )
 389         {
 390             copy_matrix (mpeg2dec, i + 2);
 391             decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
 392         }
 393         else if( mpeg2dec->copy_matrix & (5 << i) )
 394         decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
 395     }
 396 #if 0
 397     decoder->load_intra_quantizer_matrix = 1;
 398     decoder->load_non_intra_quantizer_matrix = 1;
 399 #endif
 400 }
 401
 402 static mpeg2_state_t invalid_end_action( mpeg2dec_t * mpeg2dec )
 403 {
 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;
 412 }
 413
 414 void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
 415 {
 416     mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
 417     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 418
 419     finalize_sequence (sequence);
 420     finalize_matrix (mpeg2dec);
 421
 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));
 430
 431     if( mpeg2dec->sequence.width != (unsigned int)-1 )
 432     {
 433         unsigned int new_byte_rate;
 434
 435         /*
 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.
 441          *
 442          * However, be careful not to alter the current sequence when
 443          * returning STATE_INVALID_END.
 444          */
 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)) )
 449         {
 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;
 455             return;
 456         }
 457         sequence->byte_rate = new_byte_rate;
 458         mpeg2dec->state = STATE_SEQUENCE_REPEATED;
 459     }
 460     else
 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 );
 467 }
 468
 469 int mpeg2_header_gop( mpeg2dec_t * mpeg2dec )
 470 {
 471     uint8_t * buffer = mpeg2dec->chunk_start;
 472     mpeg2_gop_t * gop = &(mpeg2dec->new_gop);
 473
 474     if( ! (buffer[1] & 8) )
 475         return 1;
 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;
 482     return 0;
 483 }
 484
 485 void mpeg2_header_gop_finalize( mpeg2dec_t * mpeg2dec )
 486 {
 487     mpeg2dec->gop = mpeg2dec->new_gop;
 488     mpeg2_reset_info( &(mpeg2dec->info) );
 489     mpeg2dec->info.gop = &(mpeg2dec->gop);
 490     info_user_data (mpeg2dec);
 491 }
 492
 493 void mpeg2_set_fbuf( mpeg2dec_t * mpeg2dec, int b_type )
 494 {
 495     int i;
 496
 497     for( i = 0; i < 3; i++ )
 498     {
 499         if( (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf) &&
 500             (mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) )
 501         {
 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) )
 505             {
 506                 if( b_type || mpeg2dec->convert )
 507                     mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
 508                 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
 509             }
 510         }
 511         break;
 512     }
 513 }
 514
 515 mpeg2_state_t mpeg2_header_picture_start( mpeg2dec_t * mpeg2dec )
 516 {
 517     mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
 518
 519     mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
 520                         STATE_PICTURE : STATE_PICTURE_2ND);
 521     picture->flags = 0;
 522     picture->tag = picture->tag2 = 0;
 523     if( mpeg2dec->num_tags )
 524     {
 525         if( mpeg2dec->bytes_since_tag >= 4 )
 526         {
 527             mpeg2dec->num_tags = 0;
 528             picture->tag = mpeg2dec->tag_current;
 529             picture->tag2 = mpeg2dec->tag2_current;
 530             picture->flags = PIC_FLAG_TAGS;
 531         }
 532         else if( mpeg2dec->num_tags > 1 )
 533         {
 534             mpeg2dec->num_tags = 1;
 535             picture->tag = mpeg2dec->tag_previous;
 536             picture->tag2 = mpeg2dec->tag2_previous;
 537             picture->flags = PIC_FLAG_TAGS;
 538         }
 539     }
 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);
 545 }
 546
 547 int mpeg2_header_picture( mpeg2dec_t * mpeg2dec )
 548 {
 549     uint8_t * buffer = mpeg2dec->chunk_start;
 550     mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
 551     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 552     int type;
 553
 554     type = (buffer [1] >> 3) & 7;
 555     mpeg2dec->ext_state = PIC_CODING_EXT;
 556
 557     picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);
 558
 559     picture->flags |= type;
 560
 561     if( (type == PIC_FLAG_CODING_TYPE_P) || (type == PIC_FLAG_CODING_TYPE_B) )
 562     {
 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;
 569     }
 570
 571     /* XXXXXX decode extra_information_picture as well */
 572     picture->nb_fields = 2;
 573
 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;
 581     return 0;
 582 }
 583
 584 static int picture_coding_ext( mpeg2dec_t * mpeg2dec )
 585 {
 586     uint8_t * buffer = mpeg2dec->chunk_start;
 587     mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
 588     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 589     uint32_t flags;
 590
 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;
 596
 597     flags = picture->flags;
 598     decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
 599     decoder->picture_structure = buffer[2] & 3;
 600
 601     switch (decoder->picture_structure)
 602     {
 603         case TOP_FIELD:
 604             //flags |= PIC_FLAG_TOP_FIELD_FIRST;
 605         case BOTTOM_FIELD:
 606             picture->nb_fields = 1;
 607             break;
 608         case FRAME_PICTURE:
 609             if( !(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) )
 610             {
 611                 picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
 612                 flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
 613             }
 614             else
 615                 picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
 616             break;
 617         default:
 618             return 1;
 619     }
 620     decoder->top_field_first = buffer[3] >> 7;
 621
 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;
 631
 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;
 636
 637     mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
 638     return 0;
 639 }
 640
 641 static int picture_display_ext( mpeg2dec_t * mpeg2dec )
 642 {
 643     uint8_t * buffer = mpeg2dec->chunk_start;
 644     mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
 645     int i, nb_pos;
 646
 647     nb_pos = picture->nb_fields;
 648     if( mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE )
 649         nb_pos >>= 1;
 650
 651     for( i = 0; i < nb_pos; i++ )
 652     {
 653         int x, y;
 654
 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);
 659         if( !(x & y & 1) )
 660             return 1;
 661         picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
 662         picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1;
 663     }
 664     for( ; i < 3; i++ )
 665     {
 666         picture->display_offset[i].x = mpeg2dec->display_offset_x;
 667         picture->display_offset[i].y = mpeg2dec->display_offset_y;
 668     }
 669     return 0;
 670 }
 671
 672 void mpeg2_header_picture_finalize( mpeg2dec_t * mpeg2dec, uint32_t accels )
 673 {
 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;
 677
 678     finalize_matrix( mpeg2dec );
 679     decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;
 680
 681     /* move in header_process_picture_header */
 682     decoder->second_field = (decoder->picture_structure != FRAME_PICTURE) &&
 683             !(decoder->second_field);
 684
 685     if( mpeg2dec->state == STATE_PICTURE )
 686     {
 687         mpeg2_picture_t * picture;
 688         mpeg2_picture_t * other;
 689
 690         /* decoder->second_field = 0; */
 691
 692         picture = other = mpeg2dec->pictures;
 693         if( old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2) )
 694             picture += 2;
 695         else
 696             other += 2;
 697         mpeg2dec->picture = picture;
 698         *picture = mpeg2dec->new_picture;
 699
 700         if( !old_type_b )
 701         {
 702             mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
 703             mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
 704         }
 705         mpeg2dec->fbuf[0] = NULL;
 706         mpeg2_reset_info (&(mpeg2dec->info));
 707         mpeg2dec->info.current_picture = picture;
 708         mpeg2dec->info.display_picture = picture;
 709
 710         if( decoder->coding_type != B_TYPE )
 711         {
 712             if (!low_delay)
 713             {
 714                 if (mpeg2dec->first)
 715                 {
 716                     mpeg2dec->info.display_picture = NULL;
 717                     mpeg2dec->first = 0;
 718                 }
 719                 else
 720                 {
 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];
 725                 }
 726             }
 727             if( !low_delay + !mpeg2dec->convert )
 728                 mpeg2dec->info.discard_fbuf =
 729                     mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
 730         }
 731         if (mpeg2dec->convert)
 732         {
 733             mpeg2_convert_init_t convert_init;
 734             if (!mpeg2dec->convert_start)
 735             {
 736                 int y_size, uv_size;
 737
 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;
 748
 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);
 771             }
 772             if (!mpeg2dec->custom_fbuf)
 773             {
 774                 while( mpeg2dec->alloc_index < 3 )
 775                 {
 776                     mpeg2_fbuf_t * fbuf;
 777
 778                     fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
 779                     fbuf->id = NULL;
 780                     fbuf->buf[0] =
 781                             (uint8_t *) mpeg2_malloc( convert_init.buf_size[0],
 782                                                       MPEG2_ALLOC_CONVERTED );
 783                     fbuf->buf[1] =
 784                             (uint8_t *) mpeg2_malloc( convert_init.buf_size[1],
 785                                                       MPEG2_ALLOC_CONVERTED );
 786                     fbuf->buf[2] =
 787                             (uint8_t *) mpeg2_malloc( convert_init.buf_size[2],
 788                                                       MPEG2_ALLOC_CONVERTED );
 789                 }
 790                 mpeg2_set_fbuf( mpeg2dec, (decoder->coding_type == B_TYPE) );
 791             }
 792         }
 793         else if( !mpeg2dec->custom_fbuf )
 794         {
 795             while (mpeg2dec->alloc_index < 3)
 796             {
 797                 mpeg2_fbuf_t * fbuf;
 798                 int y_size, uv_size;
 799
 800                 fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
 801                 fbuf->id = NULL;
 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,
 805                                                          MPEG2_ALLOC_YUV );
 806                 fbuf->buf[1] = (uint8_t *) mpeg2_malloc( uv_size,
 807                                                          MPEG2_ALLOC_YUV );
 808                 fbuf->buf[2] = (uint8_t *) mpeg2_malloc( uv_size,
 809                                                          MPEG2_ALLOC_YUV );
 810             }
 811             mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
 812         }
 813     }
 814     else
 815     {
 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;
 822     }
 823     info_user_data( mpeg2dec );
 824 }
 825
 826 static int copyright_ext( mpeg2dec_t * mpeg2dec )
 827 {
 828     return 0;
 829 }
 830
 831 static int quant_matrix_ext( mpeg2dec_t * mpeg2dec )
 832 {
 833     uint8_t * buffer = mpeg2dec->chunk_start;
 834     int i, j;
 835
 836     for (i = 0; i < 4; i++)
 837     {
 838         if (buffer[0] & (8 >> i))
 839         {
 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;
 844             buffer += 64;
 845         }
 846     }
 847     return 0;
 848 }
 849
 850 int mpeg2_header_extension( mpeg2dec_t * mpeg2dec )
 851 {
 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
 855                 };
 856     int ext, ext_bit;
 857
 858     ext = mpeg2dec->chunk_start[0] >> 4;
 859     ext_bit = 1 << ext;
 860
 861     if( !(mpeg2dec->ext_state & ext_bit) )
 862         return 0; /* ignore illegal extensions */
 863     mpeg2dec->ext_state &= ~ext_bit;
 864     return parser[ext] (mpeg2dec);
 865 }
 866
 867 int mpeg2_header_user_data( mpeg2dec_t * mpeg2dec )
 868 {
 869     mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
 870     mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
 871     return 0;
 872 }
 873
 874 static void prescale( mpeg2dec_t * mpeg2dec, int index )
 875 {
 876     static int non_linear_scale [] =
 877     {
 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
 882     };
 883     int i, j, k;
 884     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 885
 886     if( mpeg2dec->scaled[index] != mpeg2dec->q_scale_type )
 887     {
 888         mpeg2dec->scaled[index] = mpeg2dec->q_scale_type;
 889         for( i = 0; i < 32; i++ )
 890         {
 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];
 895         }
 896     }
 897 }
 898
 899 mpeg2_state_t mpeg2_header_slice_start( mpeg2dec_t * mpeg2dec )
 900 {
 901     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 902
 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);
 908
 909     if (mpeg2dec->decoder.coding_type != D_TYPE)
 910     {
 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 )
 915         {
 916             prescale (mpeg2dec, 1);
 917             if( decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3] )
 918                 prescale (mpeg2dec, 3);
 919         }
 920     }
 921
 922     if( !(mpeg2dec->nb_decode_slices) )
 923         mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
 924     else if( mpeg2dec->convert_start )
 925     {
 926         mpeg2dec->convert_start( decoder->convert_id, mpeg2dec->fbuf[0],
 927                                  mpeg2dec->picture, mpeg2dec->info.gop );
 928
 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] );
 933         else
 934         {
 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;
 941         }
 942     }
 943     else
 944     {
 945         int b_type;
 946
 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 );
 951     }
 952     mpeg2dec->action = NULL;
 953     return (mpeg2_state_t)-1;
 954 }
 955
 956 static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec)
 957 {
 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);
 964 }
 965
 966 mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
 967 {
 968     mpeg2_picture_t * picture;
 969     int b_type;
 970
 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;
 975
 976     mpeg2_reset_info (&(mpeg2dec->info));
 977     if( !(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
 978     {
 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];
 985     }
 986     else if( !mpeg2dec->convert )
 987         mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
 988     mpeg2dec->action = seek_sequence;
 989     return STATE_END;
 990 }