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