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