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