allow alignment without ATTRIBUTE_ALIGNED_MAX been defined, it fixes sparc unaligned...
[mplayer.git] / libmpeg2 / header.c
index f4f256a..e351af5 100644 (file)
@@ -1,8 +1,11 @@
 /*
- * slice.c
- * Copyright (C) 1999-2001 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
+ * header.c
+ * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
+ * Copyright (C) 2003      Regis Duchesne <hpreg@zoy.org>
+ * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  *
  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
+ * See http://libmpeg2.sourceforge.net/ for updates.
  *
  * mpeg2dec is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
 #include "config.h"
 
 #include <inttypes.h>
+#include <stdlib.h>    /* defines NULL */
+#include <string.h>    /* memcmp */
 
-#include "mpeg2_internal.h"
+#include "mpeg2.h"
 #include "attributes.h"
+#include "mpeg2_internal.h"
+
+#define SEQ_EXT 2
+#define SEQ_DISPLAY_EXT 4
+#define QUANT_MATRIX_EXT 8
+#define COPYRIGHT_EXT 0x10
+#define PIC_DISPLAY_EXT 0x80
+#define PIC_CODING_EXT 0x100
 
 /* default intra quant matrix, in zig-zag order */
-static uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) = {
+static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) = {
     8,
     16, 16,
     19, 16, 19,
@@ -45,238 +58,839 @@ static uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) = {
     83
 };
 
-uint8_t scan_norm[64] ATTR_ALIGN(16) =
-{
+uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) = {
     /* Zig-Zag scan pattern */
-     0, 1, 8,16, 9, 2, 3,10,
-    17,24,32,25,18,11, 4, 5,
-    12,19,26,33,40,48,41,34,
-    27,20,13, 6, 7,14,21,28,
-    35,42,49,56,57,50,43,36,
-    29,22,15,23,30,37,44,51,
-    58,59,52,45,38,31,39,46,
-    53,60,61,54,47,55,62,63
+     0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
 };
 
-uint8_t scan_alt[64] ATTR_ALIGN(16) =
-{
+uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) = {
     /* Alternate scan pattern */
-    0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
-    41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
-    51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
-    53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
+     0, 8,  16, 24,  1,  9,  2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
+    41, 33, 26, 18,  3, 11,  4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
+    51, 59, 20, 28,  5, 13,  6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
+    53, 61, 22, 30,  7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
 };
 
-void header_state_init (picture_t * picture)
+void mpeg2_header_state_init (mpeg2dec_t * mpeg2dec)
 {
-    picture->scan = scan_norm;
+    if (mpeg2dec->sequence.width != (unsigned)-1) {
+       int i;
+
+       mpeg2dec->sequence.width = (unsigned)-1;
+       if (!mpeg2dec->custom_fbuf)
+           for (i = mpeg2dec->alloc_index_user;
+                i < mpeg2dec->alloc_index; i++) {
+               mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]);
+               mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[1]);
+               mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[2]);
+           }
+       if (mpeg2dec->convert_start)
+           for (i = 0; i < 3; i++) {
+               mpeg2_free (mpeg2dec->yuv_buf[i][0]);
+               mpeg2_free (mpeg2dec->yuv_buf[i][1]);
+               mpeg2_free (mpeg2dec->yuv_buf[i][2]);
+           }
+       if (mpeg2dec->decoder.convert_id)
+           mpeg2_free (mpeg2dec->decoder.convert_id);
+    }
+    mpeg2dec->decoder.coding_type = I_TYPE;
+    mpeg2dec->decoder.convert = NULL;
+    mpeg2dec->decoder.convert_id = NULL;
+    mpeg2dec->picture = mpeg2dec->pictures;
+    memset(&mpeg2dec->fbuf_alloc[0].fbuf, 0, sizeof(mpeg2_fbuf_t));
+    memset(&mpeg2dec->fbuf_alloc[1].fbuf, 0, sizeof(mpeg2_fbuf_t));
+    memset(&mpeg2dec->fbuf_alloc[2].fbuf, 0, sizeof(mpeg2_fbuf_t));
+    mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf;
+    mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf;
+    mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf;
+    mpeg2dec->first = 1;
+    mpeg2dec->alloc_index = 0;
+    mpeg2dec->alloc_index_user = 0;
+    mpeg2dec->first_decode_slice = 1;
+    mpeg2dec->nb_decode_slices = 0xb0 - 1;
+    mpeg2dec->convert = NULL;
+    mpeg2dec->convert_start = NULL;
+    mpeg2dec->custom_fbuf = 0;
+    mpeg2dec->yuv_index = 0;
 }
 
-int header_process_sequence_header (picture_t * picture, uint8_t * buffer)
+void mpeg2_reset_info (mpeg2_info_t * info)
 {
-    int width, height;
-    int i;
+    info->current_picture = info->current_picture_2nd = NULL;
+    info->display_picture = info->display_picture_2nd = NULL;
+    info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL;
+}
 
-    if ((buffer[6] & 0x20) != 0x20){
-       printf("missing marker bit!\n");
-       return 1;       /* missing marker_bit */
+static void info_user_data (mpeg2dec_t * mpeg2dec)
+{
+    if (mpeg2dec->user_data_len) {
+       mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
+       mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
     }
+}
 
-    height = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
+int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec)
+{
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
+    static unsigned int frame_period[16] = {
+       0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
+       /* unofficial: xing 15 fps */
+       1800000,
+       /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
+       5400000, 2700000, 2250000, 1800000, 0, 0
+    };
+    int i;
 
-    picture->display_picture_width = (height >> 12);
-    picture->display_picture_height = (height & 0xfff);
+    if ((buffer[6] & 0x20) != 0x20)    /* missing marker_bit */
+       return 1;
 
-    width = ((height >> 12) + 15) & ~15;
-    height = ((height & 0xfff) + 15) & ~15;
+    i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
+    if (! (sequence->display_width = sequence->picture_width = i >> 12))
+       return 1;
+    if (! (sequence->display_height = sequence->picture_height = i & 0xfff))
+       return 1;
+    sequence->width = (sequence->picture_width + 15) & ~15;
+    sequence->height = (sequence->picture_height + 15) & ~15;
+    sequence->chroma_width = sequence->width >> 1;
+    sequence->chroma_height = sequence->height >> 1;
 
-    if ((width > 768) || (height > 576)){
-       printf("size restrictions for MP@ML or MPEG1 exceeded! (%dx%d)\n",width,height);
-//     return 1;       /* size restrictions for MP@ML or MPEG1 */
-    }
-    
-    picture->coded_picture_width = width;
-    picture->coded_picture_height = height;
+    sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE |
+                      SEQ_VIDEO_FORMAT_UNSPECIFIED);
+
+    sequence->pixel_width = buffer[3] >> 4;    /* aspect ratio */
+    sequence->frame_period = frame_period[buffer[3] & 15];
 
-    /* this is not used by the decoder */
-    picture->aspect_ratio_information = buffer[3] >> 4;
-    picture->frame_rate_code = buffer[3] & 15;
-    picture->bitrate = (buffer[4]<<10)|(buffer[5]<<2)|(buffer[6]>>6);
+    sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
 
+    sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
+
+    if (buffer[7] & 4)
+       sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
+
+    mpeg2dec->copy_matrix = 3;
     if (buffer[7] & 2) {
        for (i = 0; i < 64; i++)
-           picture->intra_quantizer_matrix[scan_norm[i]] =
+           mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
                (buffer[i+7] << 7) | (buffer[i+8] >> 1);
        buffer += 64;
-    } else {
+    } else
        for (i = 0; i < 64; i++)
-           picture->intra_quantizer_matrix[scan_norm[i]] =
-               default_intra_quantizer_matrix [i];
-    }
+           mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
+               default_intra_quantizer_matrix[i];
 
-    if (buffer[7] & 1) {
+    if (buffer[7] & 1)
        for (i = 0; i < 64; i++)
-           picture->non_intra_quantizer_matrix[scan_norm[i]] =
+           mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =
                buffer[i+8];
-    } else {
-       for (i = 0; i < 64; i++)
-           picture->non_intra_quantizer_matrix[i] = 16;
+    else
+       memset (mpeg2dec->new_quantizer_matrix[1], 16, 64);
+
+    sequence->profile_level_id = 0x80;
+    sequence->colour_primaries = 0;
+    sequence->transfer_characteristics = 0;
+    sequence->matrix_coefficients = 0;
+
+    mpeg2dec->ext_state = SEQ_EXT;
+    mpeg2dec->state = STATE_SEQUENCE;
+    mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0;
+
+    return 0;
+}
+
+static int sequence_ext (mpeg2dec_t * mpeg2dec)
+{
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
+    uint32_t flags;
+
+    if (!(buffer[3] & 1))
+       return 1;
+
+    sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
+
+    sequence->display_width = sequence->picture_width +=
+       ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
+    sequence->display_height = sequence->picture_height +=
+       (buffer[2] << 7) & 0x3000;
+    sequence->width = (sequence->picture_width + 15) & ~15;
+    sequence->height = (sequence->picture_height + 15) & ~15;
+    flags = sequence->flags | SEQ_FLAG_MPEG2;
+    if (!(buffer[1] & 8)) {
+       flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
+       sequence->height = (sequence->height + 31) & ~31;
     }
+    if (buffer[5] & 0x80)
+       flags |= SEQ_FLAG_LOW_DELAY;
+    sequence->flags = flags;
+    sequence->chroma_width = sequence->width;
+    sequence->chroma_height = sequence->height;
+    switch (buffer[1] & 6) {
+    case 0:    /* invalid */
+       return 1;
+    case 2:    /* 4:2:0 */
+       sequence->chroma_height >>= 1;
+    case 4:    /* 4:2:2 */
+       sequence->chroma_width >>= 1;
+    }
+
+    sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000;
+
+    sequence->vbv_buffer_size |= buffer[4] << 21;
 
-    /* MPEG1 - for testing only */
-    picture->mpeg1 = 1;
-    picture->intra_dc_precision = 0;
-    picture->frame_pred_frame_dct = 1;
-    picture->q_scale_type = 0;
-    picture->concealment_motion_vectors = 0;
-    /* picture->alternate_scan = 0; */
-    picture->picture_structure = FRAME_PICTURE;
-    /* picture->second_field = 0; */
+    sequence->frame_period =
+       sequence->frame_period * ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1);
+
+    mpeg2dec->ext_state = SEQ_DISPLAY_EXT;
 
     return 0;
 }
 
-static int header_process_sequence_extension (picture_t * picture,
-                                             uint8_t * buffer)
+static int sequence_display_ext (mpeg2dec_t * mpeg2dec)
 {
-    /* check chroma format, size extensions, marker bit */
-    if (((buffer[1] & 0x07) != 0x02) || (buffer[2] & 0xe0) ||
-       ((buffer[3] & 0x01) != 0x01))
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
+    uint32_t flags;
+
+    flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
+            ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
+    if (buffer[0] & 1) {
+       flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
+       sequence->colour_primaries = buffer[1];
+       sequence->transfer_characteristics = buffer[2];
+       sequence->matrix_coefficients = buffer[3];
+       buffer += 3;
+    }
+
+    if (!(buffer[2] & 2))      /* missing marker_bit */
        return 1;
 
-    /* this is not used by the decoder */
-    picture->progressive_sequence = (buffer[1] >> 3) & 1;
+    sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
+    sequence->display_height =
+       ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
+
+    return 0;
+}
+
+static inline void finalize_sequence (mpeg2_sequence_t * sequence)
+{
+    int width;
+    int height;
+
+    sequence->byte_rate *= 50;
+
+    if (sequence->flags & SEQ_FLAG_MPEG2) {
+       switch (sequence->pixel_width) {
+       case 1:         /* square pixels */
+           sequence->pixel_width = sequence->pixel_height = 1; return;
+       case 2:         /* 4:3 aspect ratio */
+           width = 4; height = 3;      break;
+       case 3:         /* 16:9 aspect ratio */
+           width = 16; height = 9;     break;
+       case 4:         /* 2.21:1 aspect ratio */
+           width = 221; height = 100;  break;
+       default:        /* illegal */
+           sequence->pixel_width = sequence->pixel_height = 0; return;
+       }
+       width *= sequence->display_height;
+       height *= sequence->display_width;
 
-    if (picture->progressive_sequence)
-       picture->coded_picture_height =
-           (picture->coded_picture_height + 31) & ~31;
+    } else {
+       if (sequence->byte_rate == 50 * 0x3ffff) 
+           sequence->byte_rate = 0;        /* mpeg-1 VBR */ 
+
+       switch (sequence->pixel_width) {
+       case 0: case 15:        /* illegal */
+           sequence->pixel_width = sequence->pixel_height = 0;         return;
+       case 1: /* square pixels */
+           sequence->pixel_width = sequence->pixel_height = 1;         return;
+       case 3: /* 720x576 16:9 */
+           sequence->pixel_width = 64; sequence->pixel_height = 45;    return;
+       case 6: /* 720x480 16:9 */
+           sequence->pixel_width = 32; sequence->pixel_height = 27;    return;
+       case 12:        /* 720*480 4:3 */
+           sequence->pixel_width = 8;  sequence->pixel_height = 9;     return;
+       default:
+           height = 88 * sequence->pixel_width + 1171;
+           width = 2000;
+       }
+    }
 
-    /* MPEG1 - for testing only */
-    picture->mpeg1 = 0;
+    sequence->pixel_width = width;
+    sequence->pixel_height = height;
+    while (width) {    /* find greatest common divisor */
+       int tmp = width;
+       width = height % tmp;
+       height = tmp;
+    }
+    sequence->pixel_width /= height;
+    sequence->pixel_height /= height;
+}
 
+static void copy_matrix (mpeg2dec_t * mpeg2dec, int index)
+{
+    if (memcmp (mpeg2dec->quantizer_matrix[index],
+               mpeg2dec->new_quantizer_matrix[index], 64)) {
+       memcpy (mpeg2dec->quantizer_matrix[index],
+               mpeg2dec->new_quantizer_matrix[index], 64);
+       mpeg2dec->scaled[index] = -1;
+    }
+}
+
+static void finalize_matrix (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    int i;
+
+    for (i = 0; i < 2; i++) {
+       if (mpeg2dec->copy_matrix & (1 << i))
+           copy_matrix (mpeg2dec, i);
+       if ((mpeg2dec->copy_matrix & (4 << i)) &&
+           memcmp (mpeg2dec->quantizer_matrix[i],
+                   mpeg2dec->new_quantizer_matrix[i+2], 64)) {
+           copy_matrix (mpeg2dec, i + 2);
+           decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
+       } else if (mpeg2dec->copy_matrix & (5 << i))
+           decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
+    }
+}
+
+static mpeg2_state_t invalid_end_action (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2_reset_info (&(mpeg2dec->info));
+    mpeg2dec->info.gop = NULL;
+    info_user_data (mpeg2dec);
+    mpeg2_header_state_init (mpeg2dec);
+    mpeg2dec->sequence = mpeg2dec->new_sequence;
+    mpeg2dec->action = mpeg2_seek_header;
+    mpeg2dec->state = STATE_SEQUENCE;
+    return STATE_SEQUENCE;
+}
+
+void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
+    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+
+    finalize_sequence (sequence);
+    finalize_matrix (mpeg2dec);
+
+    decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
+    decoder->width = sequence->width;
+    decoder->height = sequence->height;
+    decoder->vertical_position_extension = (sequence->picture_height > 2800);
+    decoder->chroma_format = ((sequence->chroma_width == sequence->width) +
+                             (sequence->chroma_height == sequence->height));
+
+    if (mpeg2dec->sequence.width != (unsigned)-1) {
+       unsigned int new_byte_rate;
+
+       /*
+        * According to 6.1.1.6, repeat sequence headers should be
+        * identical to the original. However some DVDs dont respect
+        * that and have different bitrates in the repeat sequence
+        * headers. So we'll ignore that in the comparison and still
+        * consider these as repeat sequence headers.
+        *
+        * However, be careful not to alter the current sequence when
+        * returning STATE_INVALID_END.
+        */
+       new_byte_rate = sequence->byte_rate;
+       sequence->byte_rate = mpeg2dec->sequence.byte_rate;
+       if (memcmp (&(mpeg2dec->sequence), sequence,
+                   sizeof (mpeg2_sequence_t))) {
+           decoder->stride_frame = sequence->width;
+           sequence->byte_rate = new_byte_rate;
+           mpeg2_header_end (mpeg2dec);
+           mpeg2dec->action = invalid_end_action;
+           mpeg2dec->state = STATE_INVALID_END;
+           return;
+       }
+       sequence->byte_rate = new_byte_rate;
+       mpeg2dec->state = STATE_SEQUENCE_REPEATED;
+    } else
+       decoder->stride_frame = sequence->width;
+    mpeg2dec->sequence = *sequence;
+    mpeg2_reset_info (&(mpeg2dec->info));
+    mpeg2dec->info.sequence = &(mpeg2dec->sequence);
+    mpeg2dec->info.gop = NULL;
+    info_user_data (mpeg2dec);
+}
+
+int mpeg2_header_gop (mpeg2dec_t * mpeg2dec)
+{
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    mpeg2_gop_t * gop = &(mpeg2dec->new_gop);
+
+    if (! (buffer[1] & 8))
+       return 1;
+    gop->hours = (buffer[0] >> 2) & 31;
+    gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
+    gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
+    gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
+    gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
+    mpeg2dec->state = STATE_GOP;
     return 0;
 }
 
-static int header_process_quant_matrix_extension (picture_t * picture,
-                                                 uint8_t * buffer)
+void mpeg2_header_gop_finalize (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2dec->gop = mpeg2dec->new_gop;
+    mpeg2_reset_info (&(mpeg2dec->info));
+    mpeg2dec->info.gop = &(mpeg2dec->gop);
+    info_user_data (mpeg2dec);
+}
+
+void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int b_type)
 {
     int i;
 
-    if (buffer[0] & 8) {
-       for (i = 0; i < 64; i++)
-           picture->intra_quantizer_matrix[scan_norm[i]] =
-               (buffer[i] << 5) | (buffer[i+1] >> 3);
-       buffer += 64;
+    for (i = 0; i < 3; i++)
+       if (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf &&
+           mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) {
+           mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf;
+           mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0];
+           if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) {
+               if (b_type || mpeg2dec->convert)
+                   mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
+               mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
+           }
+           break;
+       }
+}
+
+mpeg2_state_t mpeg2_header_picture_start (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
+
+    mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
+                      STATE_PICTURE : STATE_PICTURE_2ND);
+    picture->flags = 0;
+    picture->tag = picture->tag2 = 0;
+    if (mpeg2dec->num_tags) {
+       if (mpeg2dec->bytes_since_tag >= 4) {
+           mpeg2dec->num_tags = 0;
+           picture->tag = mpeg2dec->tag_current;
+           picture->tag2 = mpeg2dec->tag2_current;
+           picture->flags = PIC_FLAG_TAGS;
+       } else if (mpeg2dec->num_tags > 1) {
+           mpeg2dec->num_tags = 1;
+           picture->tag = mpeg2dec->tag_previous;
+           picture->tag2 = mpeg2dec->tag2_previous;
+           picture->flags = PIC_FLAG_TAGS;
+       }
     }
+    picture->display_offset[0].x = picture->display_offset[1].x =
+       picture->display_offset[2].x = mpeg2dec->display_offset_x;
+    picture->display_offset[0].y = picture->display_offset[1].y =
+       picture->display_offset[2].y = mpeg2dec->display_offset_y;
+    return mpeg2_parse_header (mpeg2dec);
+}
 
-    if (buffer[0] & 4) {
-       for (i = 0; i < 64; i++)
-           picture->non_intra_quantizer_matrix[scan_norm[i]] =
-               (buffer[i] << 6) | (buffer[i+1] >> 2);
+int mpeg2_header_picture (mpeg2dec_t * mpeg2dec)
+{
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
+    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    int type;
+
+    type = (buffer [1] >> 3) & 7;
+    mpeg2dec->ext_state = PIC_CODING_EXT;
+
+    picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);
+
+    picture->flags |= type;
+
+    if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) {
+       /* forward_f_code and backward_f_code - used in mpeg1 only */
+       decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
+       decoder->f_motion.f_code[0] =
+           (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
+       decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1;
+       decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
     }
 
+    /* XXXXXX decode extra_information_picture as well */
+
+    picture->nb_fields = 2;
+
+    mpeg2dec->q_scale_type = 0;
+    decoder->intra_dc_precision = 7;
+    decoder->frame_pred_frame_dct = 1;
+    decoder->concealment_motion_vectors = 0;
+    decoder->scan = mpeg2_scan_norm;
+    decoder->picture_structure = FRAME_PICTURE;
+    mpeg2dec->copy_matrix = 0;
+
     return 0;
 }
 
-static int header_process_picture_coding_extension (picture_t * picture, uint8_t * buffer)
+static int picture_coding_ext (mpeg2dec_t * mpeg2dec)
 {
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
+    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    uint32_t flags;
+
     /* pre subtract 1 for use later in compute_motion_vector */
-    picture->f_motion.f_code[0] = (buffer[0] & 15) - 1;
-    picture->f_motion.f_code[1] = (buffer[1] >> 4) - 1;
-    picture->b_motion.f_code[0] = (buffer[1] & 15) - 1;
-    picture->b_motion.f_code[1] = (buffer[2] >> 4) - 1;
-
-    picture->intra_dc_precision = (buffer[2] >> 2) & 3;
-    picture->picture_structure = buffer[2] & 3;
-    picture->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
-    picture->concealment_motion_vectors = (buffer[3] >> 5) & 1;
-    picture->q_scale_type = (buffer[3] >> 4) & 1;
-    picture->intra_vlc_format = (buffer[3] >> 3) & 1;
-
-    if (buffer[3] & 4) /* alternate_scan */
-       picture->scan = scan_alt;
-    else
-       picture->scan = scan_norm;
-
-    /* these are not used by the decoder */
-    picture->top_field_first = buffer[3] >> 7;
-    picture->repeat_first_field = (buffer[3] >> 1) & 1;
-    picture->progressive_frame = buffer[4] >> 7;
-
-#if 1
-    // repeat_first implementation by A'rpi/ESP-team, based on libmpeg3:
-    picture->display_time=100;
-    if(picture->repeat_first_field){
-        if(picture->progressive_sequence){
-            if(picture->top_field_first)
-                picture->display_time+=200;
-            else
-                picture->display_time+=100;
-        } else
-        if(picture->progressive_frame){
-                picture->display_time+=50;
-        }
+    decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1;
+    decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1;
+    decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1;
+    decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1;
+
+    flags = picture->flags;
+    decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
+    decoder->picture_structure = buffer[2] & 3;
+    switch (decoder->picture_structure) {
+    case TOP_FIELD:
+       flags |= PIC_FLAG_TOP_FIELD_FIRST;
+    case BOTTOM_FIELD:
+       picture->nb_fields = 1;
+       break;
+    case FRAME_PICTURE:
+       if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)) {
+           picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
+           flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
+           flags |= (buffer[3] &   2) ? PIC_FLAG_REPEAT_FIRST_FIELD : 0;
+       } else
+           picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
+       break;
+    default:
+       return 1;
     }
-    //repeat_count=display_time-100%
-#else
+    decoder->top_field_first = buffer[3] >> 7;
+    decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
+    decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1;
+    mpeg2dec->q_scale_type = buffer[3] & 16;
+    decoder->intra_vlc_format = (buffer[3] >> 3) & 1;
+    decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm;
+    flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0;
+    if (buffer[4] & 0x40)
+       flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) &
+                 PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
+    picture->flags = flags;
+
+    mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
 
+    return 0;
+}
 
-   // repeat_first implemantation by iive, based on A'rpi/ESP-team and libmpeg3
-    if( picture->progressive_sequence == 1 )
-    {
-        if( picture->repeat_first_field == 0 ) picture->display_time=100;//normal
-       else
-       {
-           if( picture->top_field_first == 0 ) picture->display_time=200;//2 frames
-           else picture->display_time=300;//3 frames
-       }
-    }else
-    {
-         if( picture->progressive_frame == 0 )
-            picture->display_time=100;//2fields, interlaced in time
-        else
-        {
-            if( picture->top_field_first == 0 ) picture->display_time=150;//reconstruct 2 fields
-            else picture->display_time = 150;//reconstruct 3 fields
-        }
-
-        if( picture->picture_structure!=3 ) picture->display_time/=2;//we calc on every field
+static int picture_display_ext (mpeg2dec_t * mpeg2dec)
+{
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
+    int i, nb_pos;
+
+    nb_pos = picture->nb_fields;
+    if (mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)
+       nb_pos >>= 1;
+
+    for (i = 0; i < nb_pos; i++) {
+       int x, y;
+
+       x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
+            (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
+       y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
+            (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
+       if (! (x & y & 1))
+           return 1;
+       picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
+       picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1;
+    }
+    for (; i < 3; i++) {
+       picture->display_offset[i].x = mpeg2dec->display_offset_x;
+       picture->display_offset[i].y = mpeg2dec->display_offset_y;
     }
-#endif
     return 0;
 }
 
-int header_process_extension (picture_t * picture, uint8_t * buffer)
+void mpeg2_header_picture_finalize (mpeg2dec_t * mpeg2dec, uint32_t accels)
 {
-    switch (buffer[0] & 0xf0) {
-    case 0x10: /* sequence extension */
-       return header_process_sequence_extension (picture, buffer);
+    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    int old_type_b = (decoder->coding_type == B_TYPE);
+    int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY;
 
-    case 0x30: /* quant matrix extension */
-       return header_process_quant_matrix_extension (picture, buffer);
+    finalize_matrix (mpeg2dec);
+    decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;
+
+    if (mpeg2dec->state == STATE_PICTURE) {
+       mpeg2_picture_t * picture;
+       mpeg2_picture_t * other;
+
+       decoder->second_field = 0;
+
+       picture = other = mpeg2dec->pictures;
+       if (old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2))
+           picture += 2;
+       else
+           other += 2;
+       mpeg2dec->picture = picture;
+       *picture = mpeg2dec->new_picture;
 
-    case 0x80: /* picture coding extension */
-       return header_process_picture_coding_extension (picture, buffer);
+       if (!old_type_b) {
+           mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
+           mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
+       }
+       mpeg2dec->fbuf[0] = NULL;
+       mpeg2_reset_info (&(mpeg2dec->info));
+       mpeg2dec->info.current_picture = picture;
+       mpeg2dec->info.display_picture = picture;
+       if (decoder->coding_type != B_TYPE) {
+           if (!low_delay) {
+               if (mpeg2dec->first) {
+                   mpeg2dec->info.display_picture = NULL;
+                   mpeg2dec->first = 0;
+               } else {
+                   mpeg2dec->info.display_picture = other;
+                   if (other->nb_fields == 1)
+                       mpeg2dec->info.display_picture_2nd = other + 1;
+                   mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1];
+               }
+           }
+           if (!low_delay + !mpeg2dec->convert)
+               mpeg2dec->info.discard_fbuf =
+                   mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
+       }
+       if (mpeg2dec->convert) {
+           mpeg2_convert_init_t convert_init;
+           if (!mpeg2dec->convert_start) {
+               int y_size, uv_size;
+
+               mpeg2dec->decoder.convert_id =
+                   mpeg2_malloc (mpeg2dec->convert_id_size,
+                                 MPEG2_ALLOC_CONVERT_ID);
+               mpeg2dec->convert (MPEG2_CONVERT_START,
+                                  mpeg2dec->decoder.convert_id,
+                                  &(mpeg2dec->sequence),
+                                  mpeg2dec->convert_stride, accels,
+                                  mpeg2dec->convert_arg, &convert_init);
+               mpeg2dec->convert_start = convert_init.start;
+               mpeg2dec->decoder.convert = convert_init.copy;
+
+               y_size = decoder->stride_frame * mpeg2dec->sequence.height;
+               uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
+               mpeg2dec->yuv_buf[0][0] =
+                   (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
+               mpeg2dec->yuv_buf[0][1] =
+                   (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+               mpeg2dec->yuv_buf[0][2] =
+                   (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+               mpeg2dec->yuv_buf[1][0] =
+                   (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
+               mpeg2dec->yuv_buf[1][1] =
+                   (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+               mpeg2dec->yuv_buf[1][2] =
+                   (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+               y_size = decoder->stride_frame * 32;
+               uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
+               mpeg2dec->yuv_buf[2][0] =
+                   (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
+               mpeg2dec->yuv_buf[2][1] =
+                   (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+               mpeg2dec->yuv_buf[2][2] =
+                   (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+           }
+           if (!mpeg2dec->custom_fbuf) {
+               while (mpeg2dec->alloc_index < 3) {
+                   mpeg2_fbuf_t * fbuf;
+
+                   fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
+                   fbuf->id = NULL;
+                   fbuf->buf[0] =
+                       (uint8_t *) mpeg2_malloc (convert_init.buf_size[0],
+                                                 MPEG2_ALLOC_CONVERTED);
+                   fbuf->buf[1] =
+                       (uint8_t *) mpeg2_malloc (convert_init.buf_size[1],
+                                                 MPEG2_ALLOC_CONVERTED);
+                   fbuf->buf[2] =
+                       (uint8_t *) mpeg2_malloc (convert_init.buf_size[2],
+                                                 MPEG2_ALLOC_CONVERTED);
+               }
+               mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
+           }
+       } else if (!mpeg2dec->custom_fbuf) {
+           while (mpeg2dec->alloc_index < 3) {
+               mpeg2_fbuf_t * fbuf;
+               int y_size, uv_size;
+
+               fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
+               fbuf->id = NULL;
+               y_size = decoder->stride_frame * mpeg2dec->sequence.height;
+               uv_size = y_size >> (2 - decoder->chroma_format);
+               fbuf->buf[0] = (uint8_t *) mpeg2_malloc (y_size,
+                                                        MPEG2_ALLOC_YUV);
+               fbuf->buf[1] = (uint8_t *) mpeg2_malloc (uv_size,
+                                                        MPEG2_ALLOC_YUV);
+               fbuf->buf[2] = (uint8_t *) mpeg2_malloc (uv_size,
+                                                        MPEG2_ALLOC_YUV);
+           }
+           mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
+       }
+    } else {
+       decoder->second_field = 1;
+       mpeg2dec->picture++;    /* second field picture */
+       *(mpeg2dec->picture) = mpeg2dec->new_picture;
+       mpeg2dec->info.current_picture_2nd = mpeg2dec->picture;
+       if (low_delay || decoder->coding_type == B_TYPE)
+           mpeg2dec->info.display_picture_2nd = mpeg2dec->picture;
     }
 
+    info_user_data (mpeg2dec);
+}
+
+static int copyright_ext (mpeg2dec_t * mpeg2dec)
+{
     return 0;
 }
 
-int header_process_picture_header (picture_t *picture, uint8_t * buffer)
+static int quant_matrix_ext (mpeg2dec_t * mpeg2dec)
 {
-    picture->picture_coding_type = (buffer [1] >> 3) & 7;
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    int i, j;
+
+    for (i = 0; i < 4; i++)
+       if (buffer[0] & (8 >> i)) {
+           for (j = 0; j < 64; j++)
+               mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] =
+                   (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i));
+           mpeg2dec->copy_matrix |= 1 << i;
+           buffer += 64;
+       }
 
-    /* forward_f_code and backward_f_code - used in mpeg1 only */
-    picture->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
-    picture->f_motion.f_code[0] =
-       (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
-    picture->b_motion.f_code[1] = (buffer[4] >> 6) & 1;
-    picture->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
+    return 0;
+}
 
-    /* move in header_process_picture_header */
-        picture->second_field =
-            (picture->picture_structure != FRAME_PICTURE) &&
-            !(picture->second_field);
+int mpeg2_header_extension (mpeg2dec_t * mpeg2dec)
+{
+    static int (* parser[]) (mpeg2dec_t *) = {
+       0, sequence_ext, sequence_display_ext, quant_matrix_ext,
+       copyright_ext, 0, 0, picture_display_ext, picture_coding_ext
+    };
+    int ext, ext_bit;
+
+    ext = mpeg2dec->chunk_start[0] >> 4;
+    ext_bit = 1 << ext;
+
+    if (!(mpeg2dec->ext_state & ext_bit))
+       return 0;       /* ignore illegal extensions */
+    mpeg2dec->ext_state &= ~ext_bit;
+    return parser[ext] (mpeg2dec);
+}
 
+int mpeg2_header_user_data (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
+    mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
+    
     return 0;
 }
+
+static void prescale (mpeg2dec_t * mpeg2dec, int index)
+{
+    static int non_linear_scale [] = {
+        0,  1,  2,  3,  4,  5,   6,   7,
+        8, 10, 12, 14, 16, 18,  20,  22,
+       24, 28, 32, 36, 40, 44,  48,  52,
+       56, 64, 72, 80, 88, 96, 104, 112
+    };
+    int i, j, k;
+    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+
+    if (mpeg2dec->scaled[index] != mpeg2dec->q_scale_type) {
+       mpeg2dec->scaled[index] = mpeg2dec->q_scale_type;
+       for (i = 0; i < 32; i++) {
+           k = mpeg2dec->q_scale_type ? non_linear_scale[i] : (i << 1);
+           decoder->quantizer_scales[i] = k;
+           for (j = 0; j < 64; j++)
+               decoder->quantizer_prescale[index][i][j] =
+                   k * mpeg2dec->quantizer_matrix[index][j];
+       }
+    }
+}
+
+mpeg2_state_t mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+
+    mpeg2dec->info.user_data = NULL;   mpeg2dec->info.user_data_len = 0;
+    mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 ||
+                       mpeg2dec->state == STATE_PICTURE_2ND) ?
+                      STATE_SLICE : STATE_SLICE_1ST);
+
+    if (mpeg2dec->decoder.coding_type != D_TYPE) {
+       prescale (mpeg2dec, 0);
+       if (decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2])
+           prescale (mpeg2dec, 2);
+       if (mpeg2dec->decoder.coding_type != I_TYPE) {
+           prescale (mpeg2dec, 1);
+           if (decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3])
+               prescale (mpeg2dec, 3);
+       }
+    }
+
+    if (!(mpeg2dec->nb_decode_slices))
+       mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
+    else if (mpeg2dec->convert_start) {
+       mpeg2dec->convert_start (decoder->convert_id, mpeg2dec->fbuf[0],
+                                mpeg2dec->picture, mpeg2dec->info.gop);
+
+       if (mpeg2dec->decoder.coding_type == B_TYPE)
+           mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->yuv_buf[2],
+                            mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
+                            mpeg2dec->yuv_buf[mpeg2dec->yuv_index]);
+       else {
+           mpeg2_init_fbuf (&(mpeg2dec->decoder),
+                            mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
+                            mpeg2dec->yuv_buf[mpeg2dec->yuv_index],
+                            mpeg2dec->yuv_buf[mpeg2dec->yuv_index]);
+           if (mpeg2dec->state == STATE_SLICE)
+               mpeg2dec->yuv_index ^= 1;
+       }
+    } else {
+       int b_type;
+
+       b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
+       mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf,
+                        mpeg2dec->fbuf[b_type + 1]->buf,
+                        mpeg2dec->fbuf[b_type]->buf);
+    }
+    mpeg2dec->action = NULL;
+    return (mpeg2_state_t)-1;
+}
+
+static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2_reset_info (&(mpeg2dec->info));
+    mpeg2dec->info.sequence = NULL;
+    mpeg2dec->info.gop = NULL;
+    mpeg2_header_state_init (mpeg2dec);
+    mpeg2dec->action = mpeg2_seek_header;
+    return mpeg2_seek_header (mpeg2dec);
+}
+
+mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
+{
+    mpeg2_picture_t * picture;
+    int b_type;
+
+    b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
+    picture = mpeg2dec->pictures;
+    if ((mpeg2dec->picture >= picture + 2) ^ b_type)
+       picture = mpeg2dec->pictures + 2;
+
+    mpeg2_reset_info (&(mpeg2dec->info));
+    if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) {
+       mpeg2dec->info.display_picture = picture;
+       if (picture->nb_fields == 1)
+           mpeg2dec->info.display_picture_2nd = picture + 1;
+       mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type];
+       if (!mpeg2dec->convert)
+           mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1];
+    } else if (!mpeg2dec->convert)
+       mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
+    mpeg2dec->action = seek_sequence;
+    return STATE_END;
+}