git.sesse.net Git - vlc/blob - modules/packetizer/vc1.c

   1 /*****************************************************************************
   2  * vc1.c
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002, 2006 the VideoLAN team
   5  * $Id: copy.c 18231 2006-12-03 17:02:02Z courmisch $
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *
  10  * This program 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  * This program 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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <stdlib.h>                                      /* malloc(), free() */
  29
  30 #include <vlc/vlc.h>
  31 #include <vlc_codec.h>
  32 #include <vlc_block.h>
  33
  34 #include "vlc_bits.h"
  35 #include "vlc_block_helper.h"
  36
  37 /*****************************************************************************
  38  * Module descriptor
  39  *****************************************************************************/
  40 static int  Open ( vlc_object_t * );
  41 static void Close( vlc_object_t * );
  42
  43 vlc_module_begin();
  44     set_category( CAT_SOUT );
  45     set_subcategory( SUBCAT_SOUT_PACKETIZER );
  46     set_description( _("VC-1 packetizer") );
  47     set_capability( "packetizer", 50 );
  48     set_callbacks( Open, Close );
  49 vlc_module_end();
  50
  51 /*****************************************************************************
  52  * Local prototypes
  53  *****************************************************************************/
  54 struct decoder_sys_t
  55 {
  56     /*
  57      * Input properties
  58      */
  59     block_bytestream_t bytestream;
  60     int i_state;
  61     int i_offset;
  62     uint8_t p_startcode[3];
  63
  64     /* Current sequence header */
  65     vlc_bool_t b_sequence_header;
  66     struct
  67     {
  68         block_t *p_sh;
  69         vlc_bool_t b_advanced_profile;
  70         vlc_bool_t b_interlaced;
  71         vlc_bool_t b_frame_interpolation;
  72         vlc_bool_t b_range_reduction;
  73         vlc_bool_t b_has_bframe;
  74     } sh;
  75     vlc_bool_t b_entry_point;
  76     struct
  77     {
  78         block_t *p_ep;
  79     } ep;
  80
  81     /* */
  82     vlc_bool_t  b_frame;
  83
  84     /* Current frame being built */
  85     block_t    *p_frame;
  86     block_t    **pp_last;
  87
  88
  89     mtime_t i_interpolated_dts;
  90 };
  91
  92 enum
  93 {
  94     STATE_NOSYNC,
  95     STATE_NEXT_SYNC
  96 };
  97
  98 typedef enum
  99 {
 100     IDU_TYPE_SEQUENCE_HEADER = 0x0f,
 101     IDU_TYPE_ENTRY_POINT = 0x0e,
 102     IDU_TYPE_FRAME = 0x0D,
 103     IDU_TYPE_FIELD = 0x0C,
 104     IDU_TYPE_SLICE = 0x0B,
 105     IDU_TYPE_END_OF_SEQUENCE = 0x0B,
 106
 107     IDU_TYPE_SEQUENCE_LEVEL_USER_DATA = 0x1F,
 108     IDU_TYPE_ENTRY_POINT_USER_DATA = 0x1E,
 109     IDU_TYPE_FRAME_USER_DATA = 0x1D,
 110     IDU_TYPE_FIELD_USER_DATA = 0x1C,
 111     IDU_TYPE_SLICE_USER_DATA = 0x1B,
 112 } idu_type_t;
 113
 114 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block );
 115
 116 /*****************************************************************************
 117  * Open: probe the packetizer and return score
 118  *****************************************************************************
 119  * Tries to launch a decoder and return score so that the interface is able
 120  * to choose.
 121  *****************************************************************************/
 122 static int Open( vlc_object_t *p_this )
 123 {
 124     decoder_t     *p_dec = (decoder_t*)p_this;
 125     decoder_sys_t *p_sys;
 126
 127     if( p_dec->fmt_in.i_codec !=  VLC_FOURCC( 'W', 'V', 'C', '1' ) )
 128         return VLC_EGENERIC;
 129
 130     p_dec->pf_packetize = Packetize;
 131
 132     /* Create the output format */
 133     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
 134     p_dec->p_sys = p_sys = malloc( sizeof( decoder_sys_t ) );
 135
 136     p_sys->i_state = STATE_NOSYNC;
 137     p_sys->bytestream = block_BytestreamInit( p_dec );
 138     p_sys->p_startcode[0] = 0x00;
 139     p_sys->p_startcode[1] = 0x00;
 140     p_sys->p_startcode[2] = 0x01;
 141     p_sys->i_offset = 0;
 142
 143     p_sys->b_sequence_header = VLC_FALSE;
 144     p_sys->sh.p_sh = NULL;
 145     p_sys->b_entry_point = VLC_FALSE;
 146     p_sys->ep.p_ep = NULL;
 147
 148     p_sys->b_frame = VLC_FALSE;
 149     p_sys->p_frame = NULL;
 150     p_sys->pp_last = &p_sys->p_frame;
 151
 152     p_sys->i_interpolated_dts = -1;
 153
 154
 155     if( p_dec->fmt_in.i_extra > 0 )
 156     {
 157         block_t *p_init = block_New( p_dec, p_dec->fmt_in.i_extra );
 158         block_t *p_pic;
 159
 160         memcpy( p_init->p_buffer, p_dec->fmt_in.p_extra,
 161                 p_dec->fmt_in.i_extra );
 162
 163         while( ( p_pic = Packetize( p_dec, &p_init ) ) )
 164             block_Release( p_pic ); /* Should not happen (only sequence header) */
 165     }
 166
 167     return VLC_SUCCESS;
 168 }
 169
 170 /*****************************************************************************
 171  * Close:
 172  *****************************************************************************/
 173 static void Close( vlc_object_t *p_this )
 174 {
 175     decoder_t     *p_dec = (decoder_t*)p_this;
 176     decoder_sys_t *p_sys = p_dec->p_sys;
 177
 178     block_BytestreamRelease( &p_sys->bytestream );
 179     if( p_sys->p_frame )
 180         block_Release( p_sys->p_frame );
 181     free( p_sys );
 182 }
 183
 184 /*****************************************************************************
 185  * Packetize: packetize an access unit
 186  *****************************************************************************/
 187 static block_t *ParseIDU( decoder_t *p_dec, block_t *p_frag );
 188
 189 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
 190 {
 191     decoder_sys_t *p_sys = p_dec->p_sys;
 192     block_t       *p_pic;
 193
 194     if( pp_block == NULL || *pp_block == NULL )
 195         return NULL;
 196
 197     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 198     {
 199         if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
 200         {
 201             p_sys->i_state = STATE_NOSYNC;
 202             block_BytestreamFlush( &p_sys->bytestream );
 203
 204             if( p_sys->p_frame )
 205                 block_ChainRelease( p_sys->p_frame );
 206             p_sys->p_frame = NULL;
 207             p_sys->pp_last = &p_sys->p_frame;
 208             p_sys->b_frame = VLC_FALSE;
 209         }
 210 //        p_sys->i_interpolated_dts = 0;
 211         block_Release( *pp_block );
 212         return NULL;
 213     }
 214
 215     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 216
 217     for( ;; )
 218     {
 219         switch( p_sys->i_state )
 220         {
 221
 222         case STATE_NOSYNC:
 223             if( block_FindStartcodeFromOffset( &p_sys->bytestream, &p_sys->i_offset, p_sys->p_startcode, 3 ) == VLC_SUCCESS )
 224                 p_sys->i_state = STATE_NEXT_SYNC;
 225
 226             if( p_sys->i_offset )
 227             {
 228                 block_SkipBytes( &p_sys->bytestream, p_sys->i_offset );
 229                 p_sys->i_offset = 0;
 230                 block_BytestreamFlush( &p_sys->bytestream );
 231             }
 232
 233             if( p_sys->i_state != STATE_NEXT_SYNC )
 234                 return NULL; /* Need more data */
 235
 236             p_sys->i_offset = 4; /* To find next startcode */
 237
 238         case STATE_NEXT_SYNC:
 239             /* TODO: If p_block == NULL, flush the buffer without checking the
 240              * next sync word */
 241
 242             /* Find the next startcode */
 243             if( block_FindStartcodeFromOffset( &p_sys->bytestream, &p_sys->i_offset, p_sys->p_startcode, 3 ) != VLC_SUCCESS )
 244                 return NULL; /* Need more data */
 245
 246             /* Get the new fragment and set the pts/dts */
 247             p_pic = block_New( p_dec, p_sys->i_offset );
 248             block_BytestreamFlush( &p_sys->bytestream );
 249             p_pic->i_pts = p_sys->bytestream.p_block->i_pts;
 250             p_pic->i_dts = p_sys->bytestream.p_block->i_dts;
 251             p_pic->i_rate = p_sys->bytestream.p_block->i_rate;
 252
 253             block_GetBytes( &p_sys->bytestream, p_pic->p_buffer, p_pic->i_buffer );
 254
 255             p_sys->i_offset = 0;
 256
 257             /* Parse and return complete frame */
 258             p_pic = ParseIDU( p_dec, p_pic );
 259
 260             /* Don't reuse the same timestamps several times */
 261             if( p_sys->p_frame &&
 262                 p_sys->p_frame->i_dts == p_sys->bytestream.p_block->i_dts &&
 263                 p_sys->p_frame->i_pts == p_sys->bytestream.p_block->i_pts )
 264             {
 265                 p_sys->bytestream.p_block->i_pts = -1;
 266                 p_sys->bytestream.p_block->i_dts = -1;
 267             }
 268
 269             /* */
 270             if( !p_pic )
 271             {
 272                 p_sys->i_state = STATE_NOSYNC;
 273                 break;
 274             }
 275             /* */
 276             if( p_sys->i_interpolated_dts < 0 )
 277             {
 278                 msg_Dbg( p_dec, "need a starting pts/dts" );
 279                 p_sys->i_state = STATE_NOSYNC;
 280                 block_Release( p_pic );
 281                 break;
 282             }
 283
 284             /* So p_block doesn't get re-added several times */
 285             *pp_block = block_BytestreamPop( &p_sys->bytestream );
 286
 287             p_sys->i_state = STATE_NOSYNC;
 288
 289             return p_pic;
 290         }
 291     }
 292 }
 293
 294 /* DecodeRIDU: decode the startcode emulation prevention (same than h264) */
 295 static void DecodeRIDU( uint8_t *p_ret, int *pi_ret, uint8_t *src, int i_src )
 296 {
 297     uint8_t *end = &src[i_src];
 298     uint8_t *dst_end = &p_ret[*pi_ret];
 299     uint8_t *dst = p_ret;
 300
 301     while( src < end && dst < dst_end )
 302     {
 303         if( src < end - 3 && src[0] == 0x00 && src[1] == 0x00 &&
 304             src[2] == 0x03 )
 305         {
 306             *dst++ = 0x00;
 307             *dst++ = 0x00;
 308
 309             src += 3;
 310             continue;
 311         }
 312         *dst++ = *src++;
 313     }
 314
 315     *pi_ret = dst - p_ret;
 316 }
 317 /* BuildExtraData: gather sequence header and entry point */
 318 static void BuildExtraData( decoder_t *p_dec )
 319 {
 320     decoder_sys_t *p_sys = p_dec->p_sys;
 321     es_format_t *p_es = &p_dec->fmt_out;
 322     int i_extra;
 323     if( !p_sys->b_sequence_header || !p_sys->b_entry_point )
 324         return;
 325
 326     i_extra = p_sys->sh.p_sh->i_buffer + p_sys->ep.p_ep->i_buffer;
 327     if( p_es->i_extra != i_extra )
 328     {
 329         p_es->i_extra = i_extra;
 330         p_es->p_extra = realloc( p_dec->fmt_out.p_extra, p_es->i_extra );
 331     }
 332     memcpy( p_es->p_extra,
 333             p_sys->sh.p_sh->p_buffer, p_sys->sh.p_sh->i_buffer );
 334     memcpy( (uint8_t*)p_es->p_extra + p_sys->sh.p_sh->i_buffer,
 335             p_sys->ep.p_ep->p_buffer, p_sys->ep.p_ep->i_buffer );
 336 }
 337 /* ParseIDU: parse an Independant Decoding Unit */
 338 static block_t *ParseIDU( decoder_t *p_dec, block_t *p_frag )
 339 {
 340     decoder_sys_t *p_sys = p_dec->p_sys;
 341     block_t *p_pic;
 342     const idu_type_t idu = p_frag->p_buffer[3];
 343
 344     if( !p_sys->b_sequence_header && idu != IDU_TYPE_SEQUENCE_HEADER )
 345     {
 346         msg_Warn( p_dec, "waiting for sequence header" );
 347         block_Release( p_frag );
 348         return NULL;
 349     }
 350     if( p_sys->b_sequence_header && !p_sys->b_entry_point && idu != IDU_TYPE_ENTRY_POINT )
 351     {
 352         msg_Warn( p_dec, "waiting for entry point" );
 353         block_Release( p_frag );
 354         return NULL;
 355     }
 356     /* TODO we do not gather ENTRY_POINT and SEQUENCE_DATA user data
 357      * But It should not be a problem for decoder */
 358
 359     /* Do we have completed a frame */
 360     p_pic = NULL;
 361     if( p_sys->b_frame &&
 362         idu != IDU_TYPE_FRAME_USER_DATA &&
 363         idu != IDU_TYPE_FIELD && idu != IDU_TYPE_FIELD_USER_DATA &&
 364         idu != IDU_TYPE_SLICE && idu != IDU_TYPE_SLICE_USER_DATA &&
 365         idu != IDU_TYPE_END_OF_SEQUENCE )
 366     {
 367         /* */
 368         p_pic = block_ChainGather( p_sys->p_frame );
 369
 370         /* We can interpolate dts/pts only if we have a frame rate */
 371         if( p_dec->fmt_out.video.i_frame_rate != 0 && p_dec->fmt_out.video.i_frame_rate_base != 0 )
 372         {
 373             //msg_Dbg( p_dec, "-------------- XXX0 dts="I64Fd" pts="I64Fd" interpolated="I64Fd, p_pic->i_dts, p_pic->i_pts, p_sys->i_interpolated_dts );
 374             if( p_pic->i_dts <= 0 )
 375                 p_pic->i_dts = p_sys->i_interpolated_dts;
 376
 377             p_sys->i_interpolated_dts += I64C(1000000) * p_dec->fmt_out.video.i_frame_rate_base / p_dec->fmt_out.video.i_frame_rate;
 378             if( p_pic->i_pts <= 0 )
 379             {
 380                 if( !p_sys->sh.b_has_bframe || (p_pic->i_flags & BLOCK_FLAG_TYPE_B ) )
 381                     p_pic->i_pts = p_pic->i_dts;
 382                 /* TODO compute pts for other case */
 383             }
 384         }
 385         p_sys->i_interpolated_dts = p_pic->i_dts;
 386
 387         //msg_Dbg( p_dec, "-------------- dts="I64Fd" pts="I64Fd, p_pic->i_dts, p_pic->i_pts );
 388
 389         /* Reset context */
 390         p_sys->p_frame = NULL;
 391         p_sys->pp_last = &p_sys->p_frame;
 392     }
 393
 394     /*  */
 395     if( p_sys->p_frame )
 396     {
 397         block_t *p_frame = p_sys->p_frame;
 398         if( p_frame->i_dts < 0 )
 399             p_frame->i_dts = p_frag->i_dts;
 400         if( p_frame->i_pts < 0 )
 401             p_frame->i_pts = p_frag->i_pts;
 402     }
 403     block_ChainLastAppend( &p_sys->pp_last, p_frag );
 404
 405     /* Parse IDU */
 406     if( idu == IDU_TYPE_SEQUENCE_HEADER )
 407     {
 408         es_format_t *p_es = &p_dec->fmt_out;
 409         bs_t s;
 410         int i_profile;
 411         uint8_t ridu[32];
 412         int     i_ridu = sizeof(ridu);
 413
 414         /* */
 415         if( p_sys->sh.p_sh )
 416             block_Release( p_sys->sh.p_sh );
 417         p_sys->sh.p_sh = block_Duplicate( p_frag );
 418
 419         /* Extract the raw IDU */
 420         DecodeRIDU( ridu, &i_ridu, &p_frag->p_buffer[4], p_frag->i_buffer - 4 );
 421
 422         /* Auto detect VC-1_SPMP_PESpacket_PayloadFormatHeader (SMPTE RP 227) for simple/main profile
 423          * TODO find a test case and valid it */
 424         if( i_ridu > 4 && (ridu[0]&0x80) == 0 ) /* for advanced profile, the first bit is 1 */
 425         {
 426             video_format_t *p_v = &p_dec->fmt_in.video;
 427             const int i_potential_width  = GetWBE( &ridu[0] );
 428             const int i_potential_height = GetWBE( &ridu[2] );
 429
 430             if( i_potential_width >= 2  && i_potential_width <= 8192 &&
 431                 i_potential_height >= 2 && i_potential_height <= 8192 )
 432             {
 433                 if( ( p_v->i_width <= 0 && p_v->i_height <= 0  ) ||
 434                     ( p_v->i_width  == i_potential_width &&  p_v->i_height == i_potential_height ) )
 435                 {
 436                     static const uint8_t startcode[4] = { 0x00, 0x00, 0x01, IDU_TYPE_SEQUENCE_HEADER };
 437                     p_es->video.i_width  = i_potential_width;
 438                     p_es->video.i_height = i_potential_height;
 439
 440                     /* Remove it */
 441                     p_frag->p_buffer += 4;
 442                     p_frag->i_buffer -= 4;
 443                     memcpy( p_frag->p_buffer, startcode, sizeof(startcode) );
 444                 }
 445             }
 446         }
 447
 448         /* Parse it */
 449         bs_init( &s, ridu, i_ridu );
 450         i_profile = bs_read( &s, 2 );
 451         if( i_profile == 3 )
 452         {
 453             const int i_level = bs_read( &s, 3 );
 454
 455             /* Advanced profile */
 456             p_sys->sh.b_advanced_profile = VLC_TRUE;
 457             p_sys->sh.b_range_reduction = VLC_FALSE;
 458             p_sys->sh.b_has_bframe = VLC_TRUE;
 459
 460             bs_skip( &s, 2+3+5+1 ); // chroma format + frame rate Q + bit rate Q + postprocflag
 461
 462             p_es->video.i_width  = 2*bs_read( &s, 12 )+2;
 463             p_es->video.i_height = 2*bs_read( &s, 12 )+2;
 464
 465             if( !p_sys->b_sequence_header )
 466                 msg_Dbg( p_dec, "found sequence header for advanced profile level L%d resolution %dx%d",
 467                          i_level, p_es->video.i_width, p_es->video.i_height);
 468
 469             bs_skip( &s, 1 );// pulldown
 470             p_sys->sh.b_interlaced = bs_read( &s, 1 );
 471             bs_skip( &s, 1 );// frame counter
 472             p_sys->sh.b_frame_interpolation = bs_read( &s, 1 );
 473             bs_skip( &s, 1 );       // Reserved
 474             bs_skip( &s, 1 );       // Psf
 475
 476             if( bs_read( &s, 1 ) )  /* Display extension */
 477             {
 478                 const int i_display_width  = bs_read( &s, 14 )+1;
 479                 const int i_display_height = bs_read( &s, 14 )+1;
 480
 481                 p_es->video.i_aspect = VOUT_ASPECT_FACTOR * i_display_width / i_display_height;
 482
 483                 if( !p_sys->b_sequence_header )
 484                     msg_Dbg( p_dec, "display size %dx%d", i_display_width, i_display_height );
 485
 486                 if( bs_read( &s, 1 ) )  /* Pixel aspect ratio (PAR/SAR) */
 487                 {
 488                     static const int p_ar[16][2] = {
 489                         { 0, 0}, { 1, 1}, {12,11}, {10,11}, {16,11}, {40,33},
 490                         {24,11}, {20,11}, {32,11}, {80,33}, {18,11}, {15,11},
 491                         {64,33}, {160,99},{ 0, 0}, { 0, 0}
 492                     };
 493                     int i_ar = bs_read( &s, 4 );
 494                     int i_ar_w, i_ar_h;
 495
 496                     if( i_ar == 15 )
 497                     {
 498                         i_ar_w = bs_read( &s, 8 );
 499                         i_ar_h = bs_read( &s, 8 );
 500                     }
 501                     else
 502                     {
 503                         i_ar_w = p_ar[i_ar][0];
 504                         i_ar_h = p_ar[i_ar][1];
 505                     }
 506                     vlc_ureduce( &i_ar_w, &i_ar_h, i_ar_w, i_ar_h, 0 );
 507                     if( !p_sys->b_sequence_header )
 508                         msg_Dbg( p_dec, "aspect ratio %d:%d", i_ar_w, i_ar_h );
 509                 }
 510             }
 511             if( bs_read( &s, 1 ) )  /* Frame rate */
 512             {
 513                 int i_fps_num = 0;
 514                 int i_fps_den = 0;
 515                 if( bs_read( &s, 1 ) )
 516                 {
 517                     i_fps_num = bs_read( &s, 16 )+1;
 518                     i_fps_den = 32;
 519                 }
 520                 else
 521                 {
 522                     const int i_nr = bs_read( &s, 8 );
 523                     const int i_dn = bs_read( &s, 4 );
 524
 525                     switch( i_nr )
 526                     {
 527                     case 1: i_fps_num = 24000; break;
 528                     case 2: i_fps_num = 25000; break;
 529                     case 3: i_fps_num = 30000; break;
 530                     case 4: i_fps_num = 50000; break;
 531                     case 5: i_fps_num = 60000; break;
 532                     case 6: i_fps_num = 48000; break;
 533                     case 7: i_fps_num = 72000; break;
 534                     }
 535                     switch( i_dn )
 536                     {
 537                     case 1: i_fps_den = 1000; break;
 538                     case 2: i_fps_den = 1001; break;
 539                     }
 540                 }
 541                 if( i_fps_num != 0 && i_fps_den != 0 )
 542                     vlc_ureduce( &p_es->video.i_frame_rate, &p_es->video.i_frame_rate_base, i_fps_num, i_fps_den, 0 );
 543
 544                 if( !p_sys->b_sequence_header )
 545                     msg_Dbg( p_dec, "frame rate %d/%d", p_es->video.i_frame_rate, p_es->video.i_frame_rate_base );
 546             }
 547         }
 548         else
 549         {
 550             /* Simple and main profile */
 551             p_sys->sh.b_advanced_profile = VLC_FALSE;
 552             p_sys->sh.b_interlaced = VLC_FALSE;
 553
 554             if( !p_sys->b_sequence_header )
 555                 msg_Dbg( p_dec, "found sequence header for %s profile", i_profile == 0 ? "simple" : "main" );
 556
 557             bs_skip( &s, 2+3+5+1+1+     // reserved + frame rate Q + bit rate Q + loop filter + reserved
 558                          1+1+1+1+2+     // multiresolution + reserved + fast uv mc + extended mv + dquant
 559                          1+1+1+1 );     // variable size transform + reserved + overlap + sync marker
 560             p_sys->sh.b_range_reduction = bs_read( &s, 1 );
 561             if( bs_read( &s, 3 ) > 0 )
 562                 p_sys->sh.b_has_bframe = VLC_TRUE;
 563             else
 564                 p_sys->sh.b_has_bframe = VLC_FALSE;
 565             bs_skip( &s, 2 );           // quantizer
 566
 567             p_sys->sh.b_frame_interpolation = bs_read( &s, 1 );
 568         }
 569         p_sys->b_sequence_header = VLC_TRUE;
 570         BuildExtraData( p_dec );
 571     }
 572     else if( idu == IDU_TYPE_ENTRY_POINT )
 573     {
 574         if( p_sys->ep.p_ep )
 575             block_Release( p_sys->ep.p_ep );
 576         p_sys->ep.p_ep = block_Duplicate( p_frag );
 577
 578         p_sys->b_entry_point = VLC_TRUE;
 579         BuildExtraData( p_dec );
 580     }
 581     else if( idu == IDU_TYPE_FRAME )
 582     {
 583         bs_t s;
 584         uint8_t ridu[8];
 585         int     i_ridu = sizeof(ridu);
 586
 587         /* Extract the raw IDU */
 588         DecodeRIDU( ridu, &i_ridu, &p_frag->p_buffer[4], p_frag->i_buffer - 4 );
 589
 590         /* Parse it + interpolate pts/dts if possible */
 591         bs_init( &s, ridu, i_ridu );
 592
 593         if( p_sys->sh.b_advanced_profile )
 594         {
 595             int i_fcm = 0;
 596
 597             if( p_sys->sh.b_interlaced )
 598             {
 599                 if( bs_read( &s, 1 ) )
 600                 {
 601                     if( bs_read( &s, 1 ) )
 602                         i_fcm = 1;  /* interlaced field */
 603                     else
 604                         i_fcm = 2;  /* interlaced frame */
 605                 }
 606             }
 607
 608             if( i_fcm == 1 ) /*interlaced field */
 609             {
 610                 /* XXX for mixed I/P we should check reference usage before marking them I (too much work) */
 611                 switch( bs_read( &s, 3 ) )
 612                 {
 613                 case 0: /* II */
 614                 case 1: /* IP */
 615                 case 2: /* PI */
 616                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
 617                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
 618                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
 619                     break;
 620                 case 3: /* PP */
 621                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
 622                     break;
 623                 case 4: /* BB */
 624                 case 5: /* BBi */
 625                 case 6: /* BiB */
 626                 case 7: /* BiBi */
 627                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
 628                     break;
 629                 }
 630             }
 631             else
 632             {
 633                 if( !bs_read( &s, 1 ) )
 634                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
 635                 else if( !bs_read( &s, 1 ) )
 636                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
 637                 else if( !bs_read( &s, 1 ) )
 638                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
 639                 else if( !bs_read( &s, 1 ) )
 640                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;   /* Bi */
 641                 else
 642                     p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;   /* P Skip */
 643             }
 644         }
 645         else
 646         {
 647             if( p_sys->sh.b_frame_interpolation )
 648                 bs_skip( &s, 1 );   // interpolate
 649             bs_skip( &s, 2 );       // frame count
 650             if( p_sys->sh.b_range_reduction )
 651                 bs_skip( &s, 1 );   // range reduction
 652
 653             if( bs_read( &s, 1 ) )
 654                 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_P;
 655             else if( !p_sys->sh.b_has_bframe || bs_read( &s, 1 ) )
 656                 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
 657             else
 658                 p_sys->p_frame->i_flags |= BLOCK_FLAG_TYPE_B;
 659         }
 660         p_sys->b_frame = VLC_TRUE;
 661     }
 662     return p_pic;
 663 }
 664