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 #include <string.h> /* memcmp */
  29
  30 #include "xxmc-config.h"
  31
  32 #include "mpeg2.h"
  33 #include "attributes.h"
  34 #include "mpeg2_internal.h"
  35
  36 #define SEQ_EXT 2
  37 #define SEQ_DISPLAY_EXT 4
  38 #define QUANT_MATRIX_EXT 8
  39 #define COPYRIGHT_EXT 0x10
  40 #define PIC_DISPLAY_EXT 0x80
  41 #define PIC_CODING_EXT 0x100
  42
  43 /* default intra quant matrix, in zig-zag order */
  44 static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) =
  45 {
  46     8,
  47     16, 16,
  48     19, 16, 19,
  49     22, 22, 22, 22,
  50     22, 22, 26, 24, 26,
  51     27, 27, 27, 26, 26, 26,
  52     26, 27, 27, 27, 29, 29, 29,
  53     34, 34, 34, 29, 29, 29, 27, 27,
  54     29, 29, 32, 32, 34, 34, 37,
  55     38, 37, 35, 35, 34, 35,
  56     38, 38, 40, 40, 40,
  57     48, 48, 46, 46,
  58     56, 56, 58,
  59     69, 69,
  60     83
  61 };
  62
  63 uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) =
  64 {
  65     /* Zig-Zag scan pattern */
  66      0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
  67     12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
  68     35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
  69     58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
  70 };
  71
  72 uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) =
  73 {
  74     /* Alternate scan pattern */
  75      0, 8,  16, 24,  1,  9,  2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
  76     41, 33, 26, 18,  3, 11,  4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
  77     51, 59, 20, 28,  5, 13,  6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
  78     53, 61, 22, 30,  7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
  79 };
  80
  81 void mpeg2_header_state_init( mpeg2dec_t *mpeg2dec )
  82 {
  83     if( mpeg2dec->sequence.width != (unsigned int)-1 )
  84     {
  85         int i;
  86
  87         mpeg2dec->sequence.width = (unsigned int)-1;
  88         if( !mpeg2dec->custom_fbuf )
  89         {
  90             for( i = mpeg2dec->alloc_index_user;
  91                  i < mpeg2dec->alloc_index; i++ )
  92             {
  93                 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[0] );
  94                 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[1] );
  95                 mpeg2_free( mpeg2dec->fbuf_alloc[i].fbuf.buf[2] );
  96             }
  97         }
  98         if( mpeg2dec->convert_start )
  99         {
 100             for( i = 0; i < 3; i++ )
 101             {
 102                 mpeg2_free( mpeg2dec->yuv_buf[i][0] );
 103                 mpeg2_free( mpeg2dec->yuv_buf[i][1] );
 104                 mpeg2_free( mpeg2dec->yuv_buf[i][2] );
 105             }
 106         }
 107         if( mpeg2dec->decoder.convert_id )
 108             mpeg2_free( mpeg2dec->decoder.convert_id );
 109     }
 110     mpeg2dec->decoder.coding_type = I_TYPE;
 111     mpeg2dec->decoder.convert = NULL;
 112     mpeg2dec->decoder.convert_id = NULL;
 113     mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
 114     mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
 115     mpeg2dec->picture = mpeg2dec->pictures;
 116     mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf;
 117     mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf;
 118     mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf;
 119     mpeg2dec->first = 1;
 120     mpeg2dec->alloc_index = 0;
 121     mpeg2dec->alloc_index_user = 0;
 122     mpeg2dec->first_decode_slice = 1;
 123     mpeg2dec->nb_decode_slices = 0xb0 - 1;
 124     mpeg2dec->convert = NULL;
 125     mpeg2dec->convert_start = NULL;
 126     mpeg2dec->custom_fbuf = 0;
 127     mpeg2dec->yuv_index = 0;
 128 }
 129
 130 void mpeg2_reset_info( mpeg2_info_t * info )
 131 {
 132     info->current_picture = info->current_picture_2nd = NULL;
 133     info->display_picture = info->display_picture_2nd = NULL;
 134     info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL;
 135 }
 136
 137 static void info_user_data( mpeg2dec_t * mpeg2dec )
 138 {
 139     if( mpeg2dec->user_data_len )
 140     {
 141         mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
 142         mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
 143     }
 144 }
 145
 146 int mpeg2_header_sequence( mpeg2dec_t * mpeg2dec )
 147 {
 148     uint8_t * buffer = mpeg2dec->chunk_start;
 149     mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
 150     static unsigned int frame_period[16] =
 151     {
 152         0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
 153         /* unofficial: xing 15 fps */
 154         1800000,
 155         /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
 156         5400000, 2700000, 2250000, 1800000, 0, 0
 157     };
 158     int i;
 159
 160     if( (buffer[6] & 0x20) != 0x20 )/* missing marker_bit */
 161         return 1;
 162
 163     i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
 164     if( !(sequence->display_width = sequence->picture_width = i >> 12) )
 165         return 1;
 166     if( !(sequence->display_height = sequence->picture_height = i & 0xfff) )
 167         return 1;
 168     sequence->width = (sequence->picture_width + 15) & ~15;
 169     sequence->height = (sequence->picture_height + 15) & ~15;
 170     sequence->chroma_width = sequence->width >> 1;
 171     sequence->chroma_height = sequence->height >> 1;
 172     sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE |
 173                        SEQ_VIDEO_FORMAT_UNSPECIFIED);
 174     sequence->aspect_ratio_information = buffer[3] >> 4;
 175     sequence->pixel_width = sequence->aspect_ratio_information; /* aspect ratio */
 176     sequence->frame_period = frame_period[buffer[3] & 15];
 177     sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
 178     sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
 179
 180     if( buffer[7] & 4 )
 181         sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
 182
 183     mpeg2dec->copy_matrix = 3;
 184     if( buffer[7] & 2 )
 185     {
 186         for( i = 0; i < 64; i++ )
 187             mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
 188                             (buffer[i+7] << 7) | (buffer[i+8] >> 1);
 189         buffer += 64;
 190     }
 191     else
 192     {
 193         for( i = 0; i < 64; i++ )
 194                 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
 195                                     default_intra_quantizer_matrix[i];
 196     }
 197
 198     if( buffer[7] & 1 )
 199     {
 200         for( i = 0; i < 64; i++ )
 201             mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =
 202                                                          buffer[i+8];
 203     }
 204     else
 205         memset( mpeg2dec->new_quantizer_matrix[1], 16, 64 );
 206
 207     mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
 208     mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
 209     sequence->profile_level_id = 0x80;
 210     sequence->colour_primaries = 0;
 211     sequence->transfer_characteristics = 0;
 212     sequence->matrix_coefficients = 0;
 213
 214     mpeg2dec->ext_state = SEQ_EXT;
 215     mpeg2dec->state = STATE_SEQUENCE;
 216     mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0;
 217     mpeg2dec->ptr_forward_ref_picture = NULL;
 218     mpeg2dec->ptr_backward_ref_picture = NULL;
 219
 220     return 0;
 221 }
 222
 223 static int sequence_ext( mpeg2dec_t * mpeg2dec )
 224 {
 225     uint8_t * buffer = mpeg2dec->chunk_start;
 226     mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
 227     uint32_t flags;
 228
 229     if( !(buffer[3] & 1) )
 230         return 1;
 231
 232     sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
 233     sequence->display_width = sequence->picture_width +=
 234                               ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
 235     sequence->display_height = sequence->picture_height +=
 236                                (buffer[2] << 7) & 0x3000;
 237     sequence->width = (sequence->picture_width + 15) & ~15;
 238     sequence->height = (sequence->picture_height + 15) & ~15;
 239     flags = sequence->flags | SEQ_FLAG_MPEG2;
 240     if( !(buffer[1] & 8) )
 241     {
 242         flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
 243         sequence->height = (sequence->height + 31) & ~31;
 244     }
 245     if( buffer[5] & 0x80 )
 246         flags |= SEQ_FLAG_LOW_DELAY;
 247     sequence->flags = flags;
 248     sequence->chroma_width = sequence->width;
 249     sequence->chroma_height = sequence->height;
 250
 251     switch( buffer[1] & 6 )
 252     {
 253         case 0: /* invalid */
 254             return 1;
 255         case 2: /* 4:2:0 */
 256             sequence->chroma_height >>= 1;
 257         case 4: /* 4:2:2 */
 258             sequence->chroma_width >>= 1;
 259     }
 260
 261     sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000;
 262     sequence->vbv_buffer_size |= buffer[4] << 21;
 263     sequence->frame_period = sequence->frame_period *
 264                             ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1);
 265     mpeg2dec->ext_state = SEQ_DISPLAY_EXT;
 266     return 0;
 267 }
 268
 269 static int sequence_display_ext( mpeg2dec_t * mpeg2dec )
 270 {
 271     uint8_t * buffer = mpeg2dec->chunk_start;
 272     mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
 273     uint32_t flags;
 274
 275     flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
 276             ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
 277     if( buffer[0] & 1 )
 278     {
 279         flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
 280         sequence->colour_primaries = buffer[1];
 281         sequence->transfer_characteristics = buffer[2];
 282         sequence->matrix_coefficients = buffer[3];
 283         buffer += 3;
 284     }
 285
 286     if( !(buffer[2] & 2) )/* missing marker_bit */
 287         return 1;
 288
 289     sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
 290     sequence->display_height =
 291             ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
 292
 293     return 0;
 294 }
 295
 296 static inline void finalize_sequence( mpeg2_sequence_t * sequence )
 297 {
 298     int width;
 299     int height;
 300
 301     sequence->byte_rate *= 50;
 302
 303     if( sequence->flags & SEQ_FLAG_MPEG2 )
 304     {
 305         switch( sequence->pixel_width )
 306         {
 307             case 1: /* square pixels */
 308                 sequence->pixel_width = sequence->pixel_height = 1;
 309                 return;
 310             case 2: /* 4:3 aspect ratio */
 311                 width = 4; height = 3;
 312                 break;
 313             case 3: /* 16:9 aspect ratio */
 314                 width = 16; height = 9;
 315                 break;
 316             case 4: /* 2.21:1 aspect ratio */
 317                 width = 221; height = 100;
 318                 break;
 319             default: /* illegal */
 320                 sequence->pixel_width = sequence->pixel_height = 0;
 321                 return;
 322         }
 323         width *= sequence->display_height;
 324         height *= sequence->display_width;
 325     }
 326     else
 327     {
 328         if( sequence->byte_rate == 50 * 0x3ffff )
 329             sequence->byte_rate = 0; /* mpeg-1 VBR */
 330
 331         switch( sequence->pixel_width )
 332         {
 333             case 0:
 334             case 15: /* illegal */
 335                 sequence->pixel_width = sequence->pixel_height = 0;
 336                 return;
 337             case 1: /* square pixels */
 338                 sequence->pixel_width = sequence->pixel_height = 1;
 339                 return;
 340             case 3: /* 720x576 16:9 */
 341                 sequence->pixel_width = 64;     sequence->pixel_height = 45;
 342                 return;
 343             case 6: /* 720x480 16:9 */
 344                 sequence->pixel_width = 32;     sequence->pixel_height = 27;
 345                 return;
 346             case 12: /* 720*480 4:3 */
 347                 sequence->pixel_width = 8;      sequence->pixel_height = 9;
 348                 return;
 349             default:
 350                 height = 88 * sequence->pixel_width + 1171;
 351                 width = 2000;
 352         }
 353    }
 354
 355     sequence->pixel_width = width;
 356     sequence->pixel_height = height;
 357     while (width)
 358     { /* find greatest common divisor */
 359         int tmp = width;
 360         width = height % tmp;
 361         height = tmp;
 362     }
 363     sequence->pixel_width /= height;
 364     sequence->pixel_height /= height;
 365 }
 366
 367 static void copy_matrix( mpeg2dec_t * mpeg2dec, int index )
 368 {
 369     if( memcmp( mpeg2dec->quantizer_matrix[index],
 370                 mpeg2dec->new_quantizer_matrix[index], 64) )
 371     {
 372         memcpy( mpeg2dec->quantizer_matrix[index],
 373                 mpeg2dec->new_quantizer_matrix[index], 64);
 374         mpeg2dec->scaled[index] = -1;
 375     }
 376 }
 377
 378 static void finalize_matrix( mpeg2dec_t * mpeg2dec )
 379 {
 380     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 381     int i;
 382
 383     for( i = 0; i < 2; i++ )
 384     {
 385         if( mpeg2dec->copy_matrix & (1 << i) )
 386             copy_matrix (mpeg2dec, i);
 387         if( (mpeg2dec->copy_matrix & (4 << i)) &&
 388             memcmp( mpeg2dec->quantizer_matrix[i],
 389                     mpeg2dec->new_quantizer_matrix[i+2], 64) )
 390         {
 391             copy_matrix (mpeg2dec, i + 2);
 392             decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
 393         }
 394         else if( mpeg2dec->copy_matrix & (5 << i) )
 395         decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
 396     }
 397 #if 0
 398     decoder->load_intra_quantizer_matrix = 1;
 399     decoder->load_non_intra_quantizer_matrix = 1;
 400 #endif
 401 }
 402
 403 static mpeg2_state_t invalid_end_action( mpeg2dec_t * mpeg2dec )
 404 {
 405     mpeg2_reset_info( &(mpeg2dec->info) );
 406     mpeg2dec->info.gop = NULL;
 407     info_user_data( mpeg2dec );
 408     mpeg2_header_state_init( mpeg2dec );
 409     mpeg2dec->sequence = mpeg2dec->new_sequence;
 410     mpeg2dec->action = mpeg2_seek_header;
 411     mpeg2dec->state = STATE_SEQUENCE;
 412     return STATE_SEQUENCE;
 413 }
 414
 415 void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
 416 {
 417     mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
 418     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 419
 420     finalize_sequence (sequence);
 421     finalize_matrix (mpeg2dec);
 422
 423     decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
 424     decoder->progressive_sequence = (sequence->flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE);
 425     decoder->aspect_ratio_information = sequence->aspect_ratio_information;
 426     decoder->width = sequence->width;
 427     decoder->height = sequence->height;
 428     decoder->vertical_position_extension = (sequence->picture_height > 2800);
 429     decoder->chroma_format = ((sequence->chroma_width == sequence->width) +
 430                               (sequence->chroma_height == sequence->height));
 431
 432     if( mpeg2dec->sequence.width != (unsigned int)-1 )
 433     {
 434         unsigned int new_byte_rate;
 435
 436         /*
 437          * According to 6.1.1.6, repeat sequence headers should be
 438          * identical to the original. However some DVDs dont respect
 439          * that and have different bitrates in the repeat sequence
 440          * headers. So we'll ignore that in the comparison and still
 441          * consider these as repeat sequence headers.
 442          *
 443          * However, be careful not to alter the current sequence when
 444          * returning STATE_INVALID_END.
 445          */
 446         new_byte_rate = sequence->byte_rate;
 447         sequence->byte_rate = mpeg2dec->sequence.byte_rate;
 448         if( memcmp( &(mpeg2dec->sequence), sequence,
 449                     sizeof (mpeg2_sequence_t)) )
 450         {
 451             decoder->stride_frame = sequence->width;
 452             sequence->byte_rate = new_byte_rate;
 453             mpeg2_header_end( mpeg2dec );
 454             mpeg2dec->action = invalid_end_action;
 455             mpeg2dec->state = STATE_INVALID_END;
 456             return;
 457         }
 458         sequence->byte_rate = new_byte_rate;
 459         mpeg2dec->state = STATE_SEQUENCE_REPEATED;
 460     }
 461     else
 462         decoder->stride_frame = sequence->width;
 463     mpeg2dec->sequence = *sequence;
 464     mpeg2_reset_info( &(mpeg2dec->info) );
 465     mpeg2dec->info.sequence = &(mpeg2dec->sequence);
 466     mpeg2dec->info.gop = NULL;
 467     info_user_data( mpeg2dec );
 468 }
 469
 470 int mpeg2_header_gop( mpeg2dec_t * mpeg2dec )
 471 {
 472     uint8_t * buffer = mpeg2dec->chunk_start;
 473     mpeg2_gop_t * gop = &(mpeg2dec->new_gop);
 474
 475     if( ! (buffer[1] & 8) )
 476         return 1;
 477     gop->hours = (buffer[0] >> 2) & 31;
 478     gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
 479     gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
 480     gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
 481     gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
 482     mpeg2dec->state = STATE_GOP;
 483     return 0;
 484 }
 485
 486 void mpeg2_header_gop_finalize( mpeg2dec_t * mpeg2dec )
 487 {
 488     mpeg2dec->gop = mpeg2dec->new_gop;
 489     mpeg2_reset_info( &(mpeg2dec->info) );
 490     mpeg2dec->info.gop = &(mpeg2dec->gop);
 491     info_user_data (mpeg2dec);
 492 }
 493
 494 void mpeg2_set_fbuf( mpeg2dec_t * mpeg2dec, int b_type )
 495 {
 496     int i;
 497
 498     for( i = 0; i < 3; i++ )
 499     {
 500         if( (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf) &&
 501             (mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) )
 502         {
 503             mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf;
 504             mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0];
 505             if( b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
 506             {
 507                 if( b_type || mpeg2dec->convert )
 508                     mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
 509                 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
 510             }
 511         }
 512         break;
 513     }
 514 }
 515
 516 mpeg2_state_t mpeg2_header_picture_start( mpeg2dec_t * mpeg2dec )
 517 {
 518     mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
 519
 520     mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
 521                         STATE_PICTURE : STATE_PICTURE_2ND);
 522     picture->flags = 0;
 523     picture->tag = picture->tag2 = 0;
 524     if( mpeg2dec->num_tags )
 525     {
 526         if( mpeg2dec->bytes_since_tag >= 4 )
 527         {
 528             mpeg2dec->num_tags = 0;
 529             picture->tag = mpeg2dec->tag_current;
 530             picture->tag2 = mpeg2dec->tag2_current;
 531             picture->flags = PIC_FLAG_TAGS;
 532         }
 533         else if( mpeg2dec->num_tags > 1 )
 534         {
 535             mpeg2dec->num_tags = 1;
 536             picture->tag = mpeg2dec->tag_previous;
 537             picture->tag2 = mpeg2dec->tag2_previous;
 538             picture->flags = PIC_FLAG_TAGS;
 539         }
 540     }
 541     picture->display_offset[0].x = picture->display_offset[1].x =
 542     picture->display_offset[2].x = mpeg2dec->display_offset_x;
 543     picture->display_offset[0].y = picture->display_offset[1].y =
 544     picture->display_offset[2].y = mpeg2dec->display_offset_y;
 545     return mpeg2_parse_header (mpeg2dec);
 546 }
 547
 548 int mpeg2_header_picture( mpeg2dec_t * mpeg2dec )
 549 {
 550     uint8_t * buffer = mpeg2dec->chunk_start;
 551     mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
 552     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 553     int type;
 554
 555     type = (buffer [1] >> 3) & 7;
 556     mpeg2dec->ext_state = PIC_CODING_EXT;
 557
 558     picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);
 559
 560     picture->flags |= type;
 561
 562     if( (type == PIC_FLAG_CODING_TYPE_P) || (type == PIC_FLAG_CODING_TYPE_B) )
 563     {
 564         /* forward_f_code and backward_f_code - used in mpeg1 only */
 565         decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
 566         decoder->f_motion.f_code[0] =
 567                             (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
 568         decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1;
 569         decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
 570     }
 571
 572     /* XXXXXX decode extra_information_picture as well */
 573     picture->nb_fields = 2;
 574
 575     mpeg2dec->q_scale_type = 0;
 576     decoder->intra_dc_precision = 7;
 577     decoder->frame_pred_frame_dct = 1;
 578     decoder->concealment_motion_vectors = 0;
 579     decoder->scan = mpeg2_scan_norm;
 580     decoder->picture_structure = FRAME_PICTURE;
 581     mpeg2dec->copy_matrix = 0;
 582     return 0;
 583 }
 584
 585 static int picture_coding_ext( mpeg2dec_t * mpeg2dec )
 586 {
 587     uint8_t * buffer = mpeg2dec->chunk_start;
 588     mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
 589     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 590     uint32_t flags;
 591
 592     /* pre subtract 1 for use later in compute_motion_vector */
 593     decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1;
 594     decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1;
 595     decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1;
 596     decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1;
 597
 598     flags = picture->flags;
 599     decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
 600     decoder->picture_structure = buffer[2] & 3;
 601
 602     switch (decoder->picture_structure)
 603     {
 604         case TOP_FIELD:
 605             //flags |= PIC_FLAG_TOP_FIELD_FIRST;
 606         case BOTTOM_FIELD:
 607             picture->nb_fields = 1;
 608             break;
 609         case FRAME_PICTURE:
 610             if( !(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) )
 611             {
 612                 picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
 613                 flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
 614             }
 615             else
 616                 picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
 617             break;
 618         default:
 619             return 1;
 620     }
 621     decoder->top_field_first = buffer[3] >> 7;
 622
 623     if( decoder->top_field_first )
 624         flags |= PIC_FLAG_TOP_FIELD_FIRST;
 625     decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
 626     decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1;
 627     decoder->q_scale_type = (buffer[3] >> 4) & 1;
 628     mpeg2dec->q_scale_type = buffer[3] & 16;
 629     decoder->intra_vlc_format = (buffer[3] >> 3) & 1;
 630     decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm;
 631     flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0;
 632
 633     if( buffer[4] & 0x40 )
 634         flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) &
 635                   PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
 636     picture->flags = flags;
 637
 638     mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
 639     return 0;
 640 }
 641
 642 static int picture_display_ext( mpeg2dec_t * mpeg2dec )
 643 {
 644     uint8_t * buffer = mpeg2dec->chunk_start;
 645     mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
 646     int i, nb_pos;
 647
 648     nb_pos = picture->nb_fields;
 649     if( mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE )
 650         nb_pos >>= 1;
 651
 652     for( i = 0; i < nb_pos; i++ )
 653     {
 654         int x, y;
 655
 656         x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
 657             (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
 658         y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
 659             (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
 660         if( !(x & y & 1) )
 661             return 1;
 662         picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
 663         picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1;
 664     }
 665     for( ; i < 3; i++ )
 666     {
 667         picture->display_offset[i].x = mpeg2dec->display_offset_x;
 668         picture->display_offset[i].y = mpeg2dec->display_offset_y;
 669     }
 670     return 0;
 671 }
 672
 673 void mpeg2_header_picture_finalize( mpeg2dec_t * mpeg2dec, uint32_t accels )
 674 {
 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;
 678
 679     finalize_matrix( mpeg2dec );
 680     decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;
 681
 682     /* move in header_process_picture_header */
 683     decoder->second_field = (decoder->picture_structure != FRAME_PICTURE) &&
 684             !(decoder->second_field);
 685
 686     if( mpeg2dec->state == STATE_PICTURE )
 687     {
 688         mpeg2_picture_t * picture;
 689         mpeg2_picture_t * other;
 690
 691         /* decoder->second_field = 0; */
 692
 693         picture = other = mpeg2dec->pictures;
 694         if( old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2) )
 695             picture += 2;
 696         else
 697             other += 2;
 698         mpeg2dec->picture = picture;
 699         *picture = mpeg2dec->new_picture;
 700
 701         if( !old_type_b )
 702         {
 703             mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
 704             mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
 705         }
 706         mpeg2dec->fbuf[0] = NULL;
 707         mpeg2_reset_info (&(mpeg2dec->info));
 708         mpeg2dec->info.current_picture = picture;
 709         mpeg2dec->info.display_picture = picture;
 710
 711         if( decoder->coding_type != B_TYPE )
 712         {
 713             if (!low_delay)
 714             {
 715                 if (mpeg2dec->first)
 716                 {
 717                     mpeg2dec->info.display_picture = NULL;
 718                     mpeg2dec->first = 0;
 719                 }
 720                 else
 721                 {
 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];
 726                 }
 727             }
 728             if( !low_delay + !mpeg2dec->convert )
 729                 mpeg2dec->info.discard_fbuf =
 730                     mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
 731         }
 732         if (mpeg2dec->convert)
 733         {
 734             mpeg2_convert_init_t convert_init;
 735             if (!mpeg2dec->convert_start)
 736             {
 737                 int y_size, uv_size;
 738
 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;
 749
 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);
 772             }
 773             if (!mpeg2dec->custom_fbuf)
 774             {
 775                 while( mpeg2dec->alloc_index < 3 )
 776                 {
 777                     mpeg2_fbuf_t * fbuf;
 778
 779                     fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
 780                     fbuf->id = NULL;
 781                     fbuf->buf[0] =
 782                             (uint8_t *) mpeg2_malloc( convert_init.buf_size[0],
 783                                                       MPEG2_ALLOC_CONVERTED );
 784                     fbuf->buf[1] =
 785                             (uint8_t *) mpeg2_malloc( convert_init.buf_size[1],
 786                                                       MPEG2_ALLOC_CONVERTED );
 787                     fbuf->buf[2] =
 788                             (uint8_t *) mpeg2_malloc( convert_init.buf_size[2],
 789                                                       MPEG2_ALLOC_CONVERTED );
 790                 }
 791                 mpeg2_set_fbuf( mpeg2dec, (decoder->coding_type == B_TYPE) );
 792             }
 793         }
 794         else if( !mpeg2dec->custom_fbuf )
 795         {
 796             while (mpeg2dec->alloc_index < 3)
 797             {
 798                 mpeg2_fbuf_t * fbuf;
 799                 int y_size, uv_size;
 800
 801                 fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
 802                 fbuf->id = NULL;
 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,
 806                                                          MPEG2_ALLOC_YUV );
 807                 fbuf->buf[1] = (uint8_t *) mpeg2_malloc( uv_size,
 808                                                          MPEG2_ALLOC_YUV );
 809                 fbuf->buf[2] = (uint8_t *) mpeg2_malloc( uv_size,
 810                                                          MPEG2_ALLOC_YUV );
 811             }
 812             mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
 813         }
 814     }
 815     else
 816     {
 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;
 823     }
 824     info_user_data( mpeg2dec );
 825 }
 826
 827 static int copyright_ext( mpeg2dec_t * mpeg2dec )
 828 {
 829     return 0;
 830 }
 831
 832 static int quant_matrix_ext( mpeg2dec_t * mpeg2dec )
 833 {
 834     uint8_t * buffer = mpeg2dec->chunk_start;
 835     int i, j;
 836
 837     for (i = 0; i < 4; i++)
 838     {
 839         if (buffer[0] & (8 >> i))
 840         {
 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;
 845             buffer += 64;
 846         }
 847     }
 848     return 0;
 849 }
 850
 851 int mpeg2_header_extension( mpeg2dec_t * mpeg2dec )
 852 {
 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
 856                 };
 857     int ext, ext_bit;
 858
 859     ext = mpeg2dec->chunk_start[0] >> 4;
 860     ext_bit = 1 << ext;
 861
 862     if( !(mpeg2dec->ext_state & ext_bit) )
 863         return 0; /* ignore illegal extensions */
 864     mpeg2dec->ext_state &= ~ext_bit;
 865     return parser[ext] (mpeg2dec);
 866 }
 867
 868 int mpeg2_header_user_data( mpeg2dec_t * mpeg2dec )
 869 {
 870     mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
 871     mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
 872     return 0;
 873 }
 874
 875 static void prescale( mpeg2dec_t * mpeg2dec, int index )
 876 {
 877     static int non_linear_scale [] =
 878     {
 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
 883     };
 884     int i, j, k;
 885     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 886
 887     if( mpeg2dec->scaled[index] != mpeg2dec->q_scale_type )
 888     {
 889         mpeg2dec->scaled[index] = mpeg2dec->q_scale_type;
 890         for( i = 0; i < 32; i++ )
 891         {
 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];
 896         }
 897     }
 898 }
 899
 900 mpeg2_state_t mpeg2_header_slice_start( mpeg2dec_t * mpeg2dec )
 901 {
 902     mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
 903
 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);
 909
 910     if (mpeg2dec->decoder.coding_type != D_TYPE)
 911     {
 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 )
 916         {
 917             prescale (mpeg2dec, 1);
 918             if( decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3] )
 919                 prescale (mpeg2dec, 3);
 920         }
 921     }
 922
 923     if( !(mpeg2dec->nb_decode_slices) )
 924         mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
 925     else if( mpeg2dec->convert_start )
 926     {
 927         mpeg2dec->convert_start( decoder->convert_id, mpeg2dec->fbuf[0],
 928                                  mpeg2dec->picture, mpeg2dec->info.gop );
 929
 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] );
 934         else
 935         {
 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;
 942         }
 943     }
 944     else
 945     {
 946         int b_type;
 947
 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 );
 952     }
 953     mpeg2dec->action = NULL;
 954     return (mpeg2_state_t)-1;
 955 }
 956
 957 static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec)
 958 {
 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);
 965 }
 966
 967 mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
 968 {
 969     mpeg2_picture_t * picture;
 970     int b_type;
 971
 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;
 976
 977     mpeg2_reset_info (&(mpeg2dec->info));
 978     if( !(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
 979     {
 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];
 986     }
 987     else if( !mpeg2dec->convert )
 988         mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
 989     mpeg2dec->action = seek_sequence;
 990     return STATE_END;
 991 }