Added VC-1 packetizer.

(But it still won't be decoded by ffmpeg, we provide extra data too late)

configure.ac

@@ -1170,6 +1170,7 @@ VLC_ADD_PLUGINS([access_directory access_file access_udp access_tcp])
 VLC_ADD_PLUGINS([access_http access_mms access_ftp])
 VLC_ADD_PLUGINS([packetizer_mpegvideo packetizer_h264])
 VLC_ADD_PLUGINS([packetizer_mpeg4video packetizer_mpeg4audio])
+VLC_ADD_PLUGINS([packetizer_vc1])
 
 
 if test "${SYS}" != "mingwce"; then

modules/packetizer/Modules.am

@@ -3,3 +3,4 @@ SOURCES_packetizer_mpegvideo = mpegvideo.c
 SOURCES_packetizer_mpeg4video = mpeg4video.c
 SOURCES_packetizer_mpeg4audio = mpeg4audio.c
 SOURCES_packetizer_h264 = h264.c
+SOURCES_packetizer_vc1 = vc1.c

modules/packetizer/vc1.c

+/*****************************************************************************
+ * vc1.c
+ *****************************************************************************
+ * Copyright (C) 2001, 2002, 2006 the VideoLAN team
+ * $Id: copy.c 18231 2006-12-03 17:02:02Z courmisch $
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#include <stdlib.h>                                      /* malloc(), free() */
+
+#include <vlc/vlc.h>
+#include <vlc_codec.h>
+#include <vlc_block.h>
+
+#include "vlc_bits.h"
+#include "vlc_block_helper.h"
+
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+static int  Open ( vlc_object_t * );
+static void Close( vlc_object_t * );
+
+vlc_module_begin();
+    set_category( CAT_SOUT );
+    set_subcategory( SUBCAT_SOUT_PACKETIZER );
+    set_description( _("VC-1 packetizer") );
+    set_capability( "packetizer", 50 );
+    set_callbacks( Open, Close );
+vlc_module_end();
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+struct decoder_sys_t
+{
+    /*
+     * Input properties
+     */
+    block_bytestream_t bytestream;
+    int i_state;
+    int i_offset;
+    uint8_t p_startcode[3];
+
+    /* Current sequence header */
+    vlc_bool_t b_sequence_header;
+    struct
+    {
+        block_t *p_sh;
+        vlc_bool_t b_advanced_profile;
+        vlc_bool_t b_interlaced;
+        vlc_bool_t b_frame_interpolation;
+        vlc_bool_t b_range_reduction;
+        vlc_bool_t b_has_bframe;
+    } sh;
+    vlc_bool_t b_entry_point;
+    struct
+    {
+        block_t *p_ep;
+    } ep;
+
+    /* */
+    vlc_bool_t  b_frame;
+
+    /* Current frame being built */
+    block_t    *p_frame;
+    block_t    **pp_last;
+
+
+    mtime_t i_interpolated_dts;
+};
+
+enum
+{
+    STATE_NOSYNC,
+    STATE_NEXT_SYNC
+};
+
+typedef enum
+{
+    IDU_TYPE_SEQUENCE_HEADER = 0x0f,
+    IDU_TYPE_ENTRY_POINT = 0x0e,
+    IDU_TYPE_FRAME = 0x0D,
+    IDU_TYPE_FIELD = 0x0C,
+    IDU_TYPE_SLICE = 0x0B,
+    IDU_TYPE_END_OF_SEQUENCE = 0x0B,
+
+    IDU_TYPE_SEQUENCE_LEVEL_USER_DATA = 0x1F,
+    IDU_TYPE_ENTRY_POINT_USER_DATA = 0x1E,
+    IDU_TYPE_FRAME_USER_DATA = 0x1D,
+    IDU_TYPE_FIELD_USER_DATA = 0x1C,
+    IDU_TYPE_SLICE_USER_DATA = 0x1B,
+} idu_type_t;
+
+static block_t *Packetize( decoder_t *p_dec, block_t **pp_block );
+
+/*****************************************************************************
+ * Open: probe the packetizer and return score
+ *****************************************************************************
+ * Tries to launch a decoder and return score so that the interface is able
+ * to choose.
+ *****************************************************************************/
+static int Open( vlc_object_t *p_this )
+{
+    decoder_t     *p_dec = (decoder_t*)p_this;
+    decoder_sys_t *p_sys;
+
+    if( p_dec->fmt_in.i_codec !=  VLC_FOURCC( 'W', 'V', 'C', '1' ) )
+        return VLC_EGENERIC;
+
+    p_dec->pf_packetize = Packetize;
+
+    /* Create the output format */
+    es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
+    p_dec->p_sys = p_sys = malloc( sizeof( decoder_sys_t ) );
+
+    p_sys->i_state = STATE_NOSYNC;
+    p_sys->bytestream = block_BytestreamInit( p_dec );
+    p_sys->p_startcode[0] = 0x00;
+    p_sys->p_startcode[1] = 0x00;
+    p_sys->p_startcode[2] = 0x01;
+    p_sys->i_offset = 0;
+
+    p_sys->b_sequence_header = VLC_FALSE;
+    p_sys->sh.p_sh = NULL;
+    p_sys->b_entry_point = VLC_FALSE;
+    p_sys->ep.p_ep = NULL;
+
+    p_sys->b_frame = VLC_FALSE;
+    p_sys->p_frame = NULL;
+    p_sys->pp_last = &p_sys->p_frame;
+
+    p_sys->i_interpolated_dts = -1;
+
+
+    if( p_dec->fmt_in.i_extra > 0 )
+    {
+        block_t *p_init = block_New( p_dec, p_dec->fmt_in.i_extra );
+        block_t *p_pic;
+
+        memcpy( p_init->p_buffer, p_dec->fmt_in.p_extra,
+                p_dec->fmt_in.i_extra );
+
+        while( ( p_pic = Packetize( p_dec, &p_init ) ) )
+            block_Release( p_pic ); /* Should not happen (only sequence header) */
+    }
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * Close:
+ *****************************************************************************/
+static void Close( vlc_object_t *p_this )
+{
+    decoder_t     *p_dec = (decoder_t*)p_this;
+    decoder_sys_t *p_sys = p_dec->p_sys;
+
+    block_BytestreamRelease( &p_sys->bytestream );
+    if( p_sys->p_frame )
+        block_Release( p_sys->p_frame );
+    free( p_sys );
+}
+
+/*****************************************************************************
+ * Packetize: packetize an access unit
+ *****************************************************************************/
+static block_t *ParseIDU( decoder_t *p_dec, block_t *p_frag );
+
+static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    block_t       *p_pic;
+
+    if( pp_block == NULL || *pp_block == NULL )
+        return NULL;
+
+    if( (*pp_block)->i_flags & BLOCK_FLAG_DISCONTINUITY )
+    {
+        block_Release( *pp_block );
+        return NULL;
+    }
+    if( (*pp_block)->i_flags & BLOCK_FLAG_CORRUPTED )
+    {
+        p_sys->i_state = STATE_NOSYNC;
+        if( p_sys->p_frame )
+            block_ChainRelease( p_sys->p_frame );
+        p_sys->p_frame = NULL;
+        p_sys->pp_last = &p_sys->p_frame;
+        block_Release( *pp_block );
+        return NULL;
+    }
+
+    block_BytestreamPush( &p_sys->bytestream, *pp_block );
+
+    for( ;; )
+    {
+        switch( p_sys->i_state )
+        {
+
+        case STATE_NOSYNC:
+            if( block_FindStartcodeFromOffset( &p_sys->bytestream, &p_sys->i_offset, p_sys->p_startcode, 3 ) == VLC_SUCCESS )
+                p_sys->i_state = STATE_NEXT_SYNC;
+
+            if( p_sys->i_offset )
+            {
+                block_SkipBytes( &p_sys->bytestream, p_sys->i_offset );
+                p_sys->i_offset = 0;
+                block_BytestreamFlush( &p_sys->bytestream );
+            }
+
+            if( p_sys->i_state != STATE_NEXT_SYNC )
+                return NULL; /* Need more data */
+
+            p_sys->i_offset = 4; /* To find next startcode */
+
+        case STATE_NEXT_SYNC:
+            /* TODO: If p_block == NULL, flush the buffer without checking the
+             * next sync word */
+
+            /* Find the next startcode */
+            if( block_FindStartcodeFromOffset( &p_sys->bytestream, &p_sys->i_offset, p_sys->p_startcode, 3 ) != VLC_SUCCESS )
+                return NULL; /* Need more data */
+
+            /* Get the new fragment and set the pts/dts */
+            p_pic = block_New( p_dec, p_sys->i_offset );
+            block_BytestreamFlush( &p_sys->bytestream );
+            p_pic->i_pts = p_sys->bytestream.p_block->i_pts;
+            p_pic->i_dts = p_sys->bytestream.p_block->i_dts;
+            p_pic->i_rate = p_sys->bytestream.p_block->i_rate;
+
+            block_GetBytes( &p_sys->bytestream, p_pic->p_buffer, p_pic->i_buffer );
+
+            p_sys->i_offset = 0;
+
+            /* Parse and return complete frame */
+            p_pic = ParseIDU( p_dec, p_pic );
+
+            /* Don't reuse the same timestamps several times */
+            if( p_sys->p_frame &&
+                p_sys->p_frame->i_dts == p_sys->bytestream.p_block->i_dts &&
+                p_sys->p_frame->i_pts == p_sys->bytestream.p_block->i_pts )
+            {
+                p_sys->bytestream.p_block->i_pts = -1;
+                p_sys->bytestream.p_block->i_dts = -1;
+            }
+
+            /* */
+            if( !p_pic )
+            {
+                p_sys->i_state = STATE_NOSYNC;
+                break;
+            }
+            /* */
+            if( p_sys->i_interpolated_dts < 0 )
+            {
+                msg_Dbg( p_dec, "need a starting pts/dts" );
+                p_sys->i_state = STATE_NOSYNC;
+                block_Release( p_pic );
+                break;
+            }
+
+            /* So p_block doesn't get re-added several times */
+            *pp_block = block_BytestreamPop( &p_sys->bytestream );
+
+            p_sys->i_state = STATE_NOSYNC;
+
+            return p_pic;
+        }
+    }
+}
+
+/* DecodeRIDU: decode the startcode emulation prevention (same than h264) */
+static void DecodeRIDU( uint8_t *p_ret, int *pi_ret, uint8_t *src, int i_src )
+{
+    uint8_t *end = &src[i_src];
+    uint8_t *dst_end = &p_ret[*pi_ret];
+    uint8_t *dst = p_ret;
+
+    while( src < end && dst < dst_end )
+    {
+        if( src < end - 3 && src[0] == 0x00 && src[1] == 0x00 &&
+            src[2] == 0x03 )
+        {
+            *dst++ = 0x00;
+            *dst++ = 0x00;
+
+            src += 3;
+            continue;
+        }
+        *dst++ = *src++;
+    }
+
+    *pi_ret = dst - p_ret;
+}
+/* BuildExtraData: gather sequence header and entry point */
+static void BuildExtraData( decoder_t *p_dec )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    es_format_t *p_es = &p_dec->fmt_out;
+    int i_extra;
+    if( !p_sys->b_sequence_header || !p_sys->b_entry_point )
+        return;
+
+    i_extra = p_sys->sh.p_sh->i_buffer + p_sys->ep.p_ep->i_buffer;
+    if( p_es->i_extra != i_extra )
+    {
+        p_es->i_extra = i_extra;
+        p_es->p_extra = realloc( p_dec->fmt_out.p_extra, p_es->i_extra );
+    }
+    memcpy( p_es->p_extra,
+            p_sys->sh.p_sh->p_buffer, p_sys->sh.p_sh->i_buffer );
+    memcpy( (uint8_t*)p_es->p_extra + p_sys->sh.p_sh->i_buffer,
+            p_sys->ep.p_ep->p_buffer, p_sys->ep.p_ep->i_buffer );
+}
+/* ParseIDU: parse an Independant Decoding Unit */
+static block_t *ParseIDU( decoder_t *p_dec, block_t *p_frag )
+{
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    block_t *p_pic;
+    const idu_type_t idu = p_frag->p_buffer[3];
+
+    if( !p_sys->b_sequence_header && idu != IDU_TYPE_SEQUENCE_HEADER )
+    {
+        msg_Warn( p_dec, "waiting for sequence header" );
+        block_Release( p_frag );
+        return NULL;
+    }
+    if( p_sys->b_sequence_header && !p_sys->b_entry_point && idu != IDU_TYPE_ENTRY_POINT )
+    {
+        msg_Warn( p_dec, "waiting for entry point" );
+        block_Release( p_frag );
+        return NULL;
+    }
+    /* TODO we do not gather ENTRY_POINT and SEQUENCE_DATA user data
+     * But It should not be a problem for decoder */
+
+    /* Do we have completed a frame */
+    p_pic = NULL;
+    if( p_sys->b_frame &&
+        idu != IDU_TYPE_FRAME_USER_DATA &&
+        idu != IDU_TYPE_FIELD && idu != IDU_TYPE_FIELD_USER_DATA &&
+        idu != IDU_TYPE_SLICE && idu != IDU_TYPE_SLICE_USER_DATA &&
+        idu != IDU_TYPE_END_OF_SEQUENCE )
+    {
+        /* */
+        p_pic = block_ChainGather( p_sys->p_frame );
+
+        /* We can interpolate dts/pts only if we have a frame rate */
+        if( p_dec->fmt_out.video.i_frame_rate != 0 && p_dec->fmt_out.video.i_frame_rate_base != 0 )
+        {
+            //msg_Dbg( p_dec, "-------------- XXX0 dts="I64Fd" pts="I64Fd" interpolated="I64Fd, p_pic->i_dts, p_pic->i_pts, p_sys->i_interpolated_dts );
+            if( p_pic->i_dts <= 0 )
+                p_pic->i_dts = p_sys->i_interpolated_dts;
+
+            p_sys->i_interpolated_dts += I64C(1000000) * p_dec->fmt_out.video.i_frame_rate_base / p_dec->fmt_out.video.i_frame_rate;
+            if( p_pic->i_pts <= 0 )
+            {
+                if( !p_sys->sh.b_has_bframe || (p_pic->i_flags & BLOCK_FLAG_TYPE_B ) )
+                    p_pic->i_pts = p_pic->i_dts;
+                /* TODO compute pts for other case */
+            }
+        }
+        p_sys->i_interpolated_dts = p_pic->i_dts;
+
+        //msg_Dbg( p_dec, "-------------- dts="I64Fd" pts="I64Fd, p_pic->i_dts, p_pic->i_pts );
+
+        /* Reset context */
+        p_sys->p_frame = NULL;
+        p_sys->pp_last = &p_sys->p_frame;
+    }
+
+    /*  */
+    if( p_sys->p_frame )
+    {
+        block_t *p_frame = p_sys->p_frame;
+        if( p_frame->i_dts < 0 )
+            p_frame->i_dts = p_frag->i_dts;
+        if( p_frame->i_pts < 0 )
+            p_frame->i_pts = p_frag->i_pts;
+    }
+    block_ChainLastAppend( &p_sys->pp_last, p_frag );
+
+    /* Parse IDU */
+    if( idu == IDU_TYPE_SEQUENCE_HEADER )
+    {
+        es_format_t *p_es = &p_dec->fmt_out;
+        bs_t s;
+        int i_profile;
+        uint8_t ridu[32];
+        int     i_ridu = sizeof(ridu);
+
+        /* */
+        if( p_sys->sh.p_sh )
+            block_Release( p_sys->sh.p_sh );
+        p_sys->sh.p_sh = block_Duplicate( p_frag );
+
+        /* Extract the raw IDU */
+        DecodeRIDU( ridu, &i_ridu, &p_frag->p_buffer[4], p_frag->i_buffer - 4 );
+
+        /* Auto detect VC-1_SPMP_PESpacket_PayloadFormatHeader (SMPTE RP 227) for simple/main profile
+         * TODO find a test case and valid it */
+        if( i_ridu > 4 && (ridu[0]&0x80) == 0 ) /* for advanced profile, the first bit is 1 */
+        {
+            video_format_t *p_v = &p_dec->fmt_in.video;
+            const int i_potential_width  = GetWBE( &ridu[0] );
+            const int i_potential_height = GetWBE( &ridu[2] );
+
+            if( i_potential_width >= 2  && i_potential_width <= 8192 &&
+                i_potential_height >= 2 && i_potential_height <= 8192 )
+            {
+                if( ( p_v->i_width <= 0 && p_v->i_height <= 0  ) ||
+                    ( p_v->i_width  == i_potential_width &&  p_v->i_height == i_potential_height ) )
+                {
+                    static const uint8_t startcode[4] = { 0x00, 0x00, 0x01, IDU_TYPE_SEQUENCE_HEADER };
+                    p_es->video.i_width  = i_potential_width;
+                    p_es->video.i_height = i_potential_height;
+
+                    /* Remove it */
+                    p_frag->p_buffer += 4;
+                    p_frag->i_buffer -= 4;
+                    memcpy( p_frag->p_buffer, startcode, sizeof(startcode) );
+                }
+            }
+        }
+
+        /* Parse it */
+        bs_init( &s, ridu, i_ridu );
+        i_profile = bs_read( &s, 2 );
+        if( i_profile == 3 )
+        {
+            const int i_level = bs_read( &s, 3 );
+
+            /* Advanced profile */
+            p_sys->sh.b_advanced_profile = VLC_TRUE;
+            p_sys->sh.b_range_reduction = VLC_FALSE;
+            p_sys->sh.b_has_bframe = VLC_TRUE;
+
+            bs_skip( &s, 2+3+5+1 ); // chroma format + frame rate Q + bit rate Q + postprocflag
+
+            p_es->video.i_width  = 2*bs_read( &s, 12 )+2;
+            p_es->video.i_height = 2*bs_read( &s, 12 )+2;
+
+            if( !p_sys->b_sequence_header )
+                msg_Dbg( p_dec, "found sequence header for advanced profile level L%d resolution %dx%d",
+                         i_level, p_es->video.i_width, p_es->video.i_height);
+
+            bs_skip( &s, 1 );// pulldown
+            p_sys->sh.b_interlaced = bs_read( &s, 1 );
+            bs_skip( &s, 1 );// frame counter
+            p_sys->sh.b_frame_interpolation = bs_read( &s, 1 );
+            bs_skip( &s, 1 );       // Reserved
+            bs_skip( &s, 1 );       // Psf
+
+            if( bs_read( &s, 1 ) )  /* Display extension */
+            {
+                const int i_display_width  = bs_read( &s, 14 )+1;
+                const int i_display_height = bs_read( &s, 14 )+1;
+
+                p_es->video.i_aspect = VOUT_ASPECT_FACTOR * i_display_width / i_display_height;
+
+                if( !p_sys->b_sequence_header )
+                    msg_Dbg( p_dec, "display size %dx%d", i_display_width, i_display_height );
+
+                if( bs_read( &s, 1 ) )  /* Pixel aspect ratio (PAR/SAR) */
+                {
+                    static const int p_ar[16][2] = {
+                        { 0, 0}, { 1, 1}, {12,11}, {10,11}, {16,11}, {40,33},
+                        {24,11}, {20,11}, {32,11}, {80,33}, {18,11}, {15,11},
+                        {64,33}, {160,99},{ 0, 0}, { 0, 0}
+                    };
+                    int i_ar = bs_read( &s, 4 );
+                    int i_ar_w, i_ar_h;
+
+                    if( i_ar == 15 )
+                    {
+                        i_ar_w = bs_read( &s, 8 );
+                        i_ar_h = bs_read( &s, 8 );
+                    }
+                    else
+                    {
+                        i_ar_w = p_ar[i_ar][0];
+                        i_ar_h = p_ar[i_ar][1];
+                    }
+                    vlc_ureduce( &i_ar_w, &i_ar_h, i_ar_w, i_ar_h, 0 );
+                    if( !p_sys->b_sequence_header )
+                        msg_Dbg( p_dec, "aspect ratio %d:%d", i_ar_w, i_ar_h );
+                }
+            }
+            if( bs_read( &s, 1 ) )  /* Frame rate */
+            {
+                int i_fps_num = 0;
+                int i_fps_den = 0;
+                if( bs_read( &s, 1 ) )
+                {
+                    i_fps_num = bs_read( &s, 16 )+1;
+                    i_fps_den = 32;
+                }
+                else
+                {
+                    const int i_nr = bs_read( &s, 8 );
+                    const int i_dn = bs_read( &s, 4 );
+
+                    switch( i_nr )
+                    {
+                    case 1: i_fps_num = 24000; break;
+                    case 2: i_fps_num = 25000; break;
+                    case 3: i_fps_num = 30000; break;
+                    case 4: i_fps_num = 50000; break;
+                    case 5: i_fps_num = 60000; break;
+                    case 6: i_fps_num = 48000; break;
+                    case 7: i_fps_num = 72000; break;
+                    }
+                    switch( i_dn )
+                    {
+                    case 1: i_fps_den = 1000; break;
+                    case 2: i_fps_den = 1001; break;
+                    }
+                }
+                if( i_fps_num != 0 && i_fps_den != 0 )
+                    vlc_ureduce( &p_es->video.i_frame_rate, &p_es->video.i_frame_rate_base, i_fps_num, i_fps_den, 0 );
+
+                if( !p_sys->b_sequence_header )
+                    msg_Dbg( p_dec, "frame rate %d/%d", p_es->video.i_frame_rate, p_es->video.i_frame_rate_base );
+            }
+        }
+        else
+        {
+            /* Simple and main profile */
+            p_sys->sh.b_advanced_profile = VLC_FALSE;
+            p_sys->sh.b_interlaced = VLC_FALSE;
+
+            if( !p_sys->b_sequence_header )
+                msg_Dbg( p_dec, "found sequence header for %s profile", i_profile == 0 ? "simple" : "main" );
+
+            bs_skip( &s, 2+3+5+1+1+     // reserved + frame rate Q + bit rate Q + loop filter + reserved
+                         1+1+1+1+2+     // multiresolution + reserved + fast uv mc + extended mv + dquant
+                         1+1+1+1 );     // variable size transform + reserved + overlap + sync marker
+            p_sys->sh.b_range_reduction = bs_read( &s, 1 );
+            if( bs_read( &s, 3 ) > 0 )
+                p_sys->sh.b_has_bframe = VLC_TRUE;
+            else
+                p_sys->sh.b_has_bframe = VLC_FALSE;
+            bs_skip( &s, 2 );           // quantizer
+
+            p_sys->sh.b_frame_interpolation = bs_read( &s, 1 );
+        }
+        p_sys->b_sequence_header = VLC_TRUE;
+        BuildExtraData( p_dec );
+    }
+    else if( idu == IDU_TYPE_ENTRY_POINT )
+    {
+        if( p_sys->ep.p_ep )
+            block_Release( p_sys->ep.p_ep );
+        p_sys->ep.p_ep = block_Duplicate( p_frag );
+
+        p_sys->b_entry_point = VLC_TRUE;
+        BuildExtraData( p_dec );
+    }
+    else if( idu == IDU_TYPE_FRAME )
+    {
+        bs_t s;
+        uint8_t ridu[8];
+        int     i_ridu = sizeof(ridu);
+
+        /* Extract the raw IDU */
+        DecodeRIDU( ridu, &i_ridu, &p_frag->p_buffer[4], p_frag->i_buffer - 4 );
+
+        /* Parse it + interpolate pts/dts if possible */
+        bs_init( &s, ridu, i_ridu );
+
+        if( p_sys->sh.b_advanced_profile )
+        {
+            int i_fcm = 0;
+
+            if( p_sys->sh.b_interlaced )
+            {
+                if( bs_read( &s, 1 ) )
+                {
+                    if( bs_read( &s, 1 ) )
+                        i_fcm = 1;  /* interlaced field */
+                    else
+                        i_fcm = 2;  /* interlaced frame */
+                }
+            }
+
+            if( i_fcm == 1 ) /*interlaced field */
+            {
+                /* XXX for mixed I/P we should check reference usage before marking them I (too much work) */
+                switch( bs_read( &s, 3 ) )
+                {
+                case 0: /* II */
+                case 1: /* IP */
+                case 2: /* PI */
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
+                    break;
+                case 3: /* PP */
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
+                    break;
+                case 4: /* BB */
+                case 5: /* BBi */
+                case 6: /* BiB */
+                case 7: /* BiBi */
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
+                    break;
+                }
+            }
+            else
+            {
+                if( !bs_read( &s, 1 ) )
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
+                else if( !bs_read( &s, 1 ) )
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
+                else if( !bs_read( &s, 1 ) )
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
+                else if( !bs_read( &s, 1 ) )
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;   /* Bi */
+                else
+                    p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;   /* P Skip */
+            }
+        }
+        else
+        {
+            if( p_sys->sh.b_frame_interpolation )
+                bs_skip( &s, 1 );   // interpolate
+            bs_skip( &s, 2 );       // frame count
+            if( p_sys->sh.b_range_reduction )
+                bs_skip( &s, 1 );   // range reduction
+
+            if( bs_read( &s, 1 ) )
+                p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
+            else if( !p_sys->sh.b_has_bframe || bs_read( &s, 1 ) )
+                p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
+            else
+                p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
+        }
+        p_sys->b_frame = VLC_TRUE;
+    }
+    return p_pic;
+}
+