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