apps/plugins/mpegplayer/header.c

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