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