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