1 /*****************************************************************************
2 * h264.c: h264/avc video packetizer
3 *****************************************************************************
4 * Copyright (C) 2001, 2002, 2006 the VideoLAN team
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Eric Petit <titer@videolan.org>
9 * Gildas Bazin <gbazin@videolan.org>
10 * Derk-Jan Hartman <hartman at videolan dot org>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25 *****************************************************************************/
27 /*****************************************************************************
29 *****************************************************************************/
37 #include <vlc_codec.h>
38 #include <vlc_block.h>
40 #include "vlc_block_helper.h"
43 /*****************************************************************************
45 *****************************************************************************/
46 static int Open ( vlc_object_t
* );
47 static void Close( vlc_object_t
* );
50 set_category( CAT_SOUT
);
51 set_subcategory( SUBCAT_SOUT_PACKETIZER
);
52 set_description( _("H.264 video packetizer") );
53 set_capability( "packetizer", 50 );
54 set_callbacks( Open
, Close
);
58 /****************************************************************************
60 ****************************************************************************/
61 static block_t
*Packetize( decoder_t
*, block_t
** );
62 static block_t
*PacketizeAVC1( decoder_t
*, block_t
** );
70 int i_pic_parameter_set_id
;
74 int i_bottom_field_flag
;
78 int i_pic_order_cnt_lsb
;
79 int i_delta_pic_order_cnt_bottom
;
81 int i_delta_pic_order_cnt0
;
82 int i_delta_pic_order_cnt1
;
87 block_bytestream_t bytestream
;
101 int i_avcC_length_size
;
105 /* Useful values of the Sequence Parameter Set */
106 int i_log2_max_frame_num
;
107 int b_frame_mbs_only
;
108 int i_pic_order_cnt_type
;
109 int i_delta_pic_order_always_zero_flag
;
110 int i_log2_max_pic_order_cnt_lsb
;
112 /* Value from Picture Parameter Set */
113 int i_pic_order_present_flag
;
115 /* Useful values of the Slice Header */
132 NAL_SLICE_IDR
= 5, /* ref_idc != 0 */
133 NAL_SEI
= 6, /* ref_idc == 0 */
137 /* ref_idc == 0 for 6,9,10,11,12 */
142 NAL_PRIORITY_DISPOSABLE
= 0,
143 NAL_PRIORITY_LOW
= 1,
144 NAL_PRIORITY_HIGH
= 2,
145 NAL_PRIORITY_HIGHEST
= 3,
148 static block_t
*ParseNALBlock( decoder_t
*, block_t
* );
150 static block_t
*nal_get_annexeb( decoder_t
*, uint8_t *p
, int );
152 /*****************************************************************************
153 * Open: probe the packetizer and return score
154 * When opening after demux, the packetizer is only loaded AFTER the decoder
155 * That means that what you set in fmt_out is ignored by the decoder in this special case
156 *****************************************************************************/
157 static int Open( vlc_object_t
*p_this
)
159 decoder_t
*p_dec
= (decoder_t
*)p_this
;
160 decoder_sys_t
*p_sys
;
162 if( p_dec
->fmt_in
.i_codec
!= VLC_FOURCC( 'h', '2', '6', '4') &&
163 p_dec
->fmt_in
.i_codec
!= VLC_FOURCC( 'H', '2', '6', '4') &&
164 p_dec
->fmt_in
.i_codec
!= VLC_FOURCC( 'V', 'S', 'S', 'H') &&
165 p_dec
->fmt_in
.i_codec
!= VLC_FOURCC( 'v', 's', 's', 'h') &&
166 p_dec
->fmt_in
.i_codec
!= VLC_FOURCC( 'D', 'A', 'V', 'C') &&
167 ( p_dec
->fmt_in
.i_codec
!= VLC_FOURCC( 'a', 'v', 'c', '1') ||
168 p_dec
->fmt_in
.i_extra
< 7 ) )
173 /* Allocate the memory needed to store the decoder's structure */
174 if( ( p_dec
->p_sys
= p_sys
= malloc( sizeof(decoder_sys_t
) ) ) == NULL
)
176 msg_Err( p_dec
, "out of memory" );
179 p_sys
->i_state
= STATE_NOSYNC
;
181 p_sys
->startcode
[0] = 0;
182 p_sys
->startcode
[1] = 0;
183 p_sys
->startcode
[2] = 0;
184 p_sys
->startcode
[3] = 1;
185 p_sys
->bytestream
= block_BytestreamInit( p_dec
);
186 p_sys
->b_slice
= VLC_FALSE
;
187 p_sys
->p_frame
= NULL
;
188 p_sys
->b_sps
= VLC_FALSE
;
189 p_sys
->b_pps
= VLC_FALSE
;
192 p_sys
->b_header
= VLC_FALSE
;
194 p_sys
->slice
.i_nal_type
= -1;
195 p_sys
->slice
.i_nal_ref_idc
= -1;
196 p_sys
->slice
.i_idr_pic_id
= -1;
197 p_sys
->slice
.i_frame_num
= -1;
198 p_sys
->slice
.i_frame_type
= 0;
199 p_sys
->slice
.i_pic_parameter_set_id
= -1;
200 p_sys
->slice
.i_field_pic_flag
= 0;
201 p_sys
->slice
.i_bottom_field_flag
= -1;
202 p_sys
->slice
.i_pic_order_cnt_lsb
= -1;
203 p_sys
->slice
.i_delta_pic_order_cnt_bottom
= -1;
205 /* Setup properties */
206 es_format_Copy( &p_dec
->fmt_out
, &p_dec
->fmt_in
);
207 p_dec
->fmt_out
.i_codec
= VLC_FOURCC( 'h', '2', '6', '4' );
209 if( p_dec
->fmt_in
.i_codec
== VLC_FOURCC( 'a', 'v', 'c', '1' ) )
211 /* This type of stream is produced by mp4 and matroska
212 * when we want to store it in another streamformat, you need to convert
213 * The fmt_in.p_extra should ALWAYS contain the avcC
214 * The fmt_out.p_extra should contain all the SPS and PPS with 4 byte startcodes */
215 uint8_t *p
= &((uint8_t*)p_dec
->fmt_in
.p_extra
)[4];
220 p_sys
->i_avcC_length_size
= 1 + ((*p
++)&0x03);
224 for( i
= 0; i
< i_sps
; i
++ )
226 int i_length
= GetWBE( p
);
227 block_t
*p_sps
= nal_get_annexeb( p_dec
, p
+ 2, i_length
);
229 p_sys
->p_sps
= block_Duplicate( p_sps
);
230 p_sps
->i_pts
= p_sps
->i_dts
= mdate();
231 ParseNALBlock( p_dec
, p_sps
);
236 for( i
= 0; i
< i_pps
; i
++ )
238 int i_length
= GetWBE( p
);
239 block_t
*p_pps
= nal_get_annexeb( p_dec
, p
+ 2, i_length
);
241 p_sys
->p_pps
= block_Duplicate( p_pps
);
242 p_pps
->i_pts
= p_pps
->i_dts
= mdate();
243 ParseNALBlock( p_dec
, p_pps
);
246 msg_Dbg( p_dec
, "avcC length size=%d, sps=%d, pps=%d",
247 p_sys
->i_avcC_length_size
, i_sps
, i_pps
);
249 /* FIXME: FFMPEG isn't happy at all if you leave this */
250 if( p_dec
->fmt_out
.i_extra
) free( p_dec
->fmt_out
.p_extra
);
251 p_dec
->fmt_out
.i_extra
= 0; p_dec
->fmt_out
.p_extra
= NULL
;
253 /* Set the new extradata */
254 p_dec
->fmt_out
.i_extra
= p_sys
->p_pps
->i_buffer
+ p_sys
->p_sps
->i_buffer
;
255 p_dec
->fmt_out
.p_extra
= (uint8_t*)malloc( p_dec
->fmt_out
.i_extra
);
256 if( p_dec
->fmt_out
.p_extra
)
258 memcpy( (uint8_t*)p_dec
->fmt_out
.p_extra
, p_sys
->p_sps
->p_buffer
, p_sys
->p_sps
->i_buffer
);
259 memcpy( (uint8_t*)p_dec
->fmt_out
.p_extra
+p_sys
->p_sps
->i_buffer
, p_sys
->p_pps
->p_buffer
, p_sys
->p_pps
->i_buffer
);
260 p_sys
->b_header
= VLC_TRUE
;
262 else p_dec
->fmt_out
.i_extra
= 0;
265 p_dec
->pf_packetize
= PacketizeAVC1
;
269 /* This type of stream contains data with 3 of 4 byte startcodes
270 * The fmt_in.p_extra MAY contain SPS/PPS with 4 byte startcodes
271 * The fmt_out.p_extra should be the same */
274 p_dec
->pf_packetize
= Packetize
;
277 if( p_dec
->fmt_in
.i_extra
> 0 )
279 block_t
*p_init
= block_New( p_dec
, p_dec
->fmt_in
.i_extra
);
282 memcpy( p_init
->p_buffer
, p_dec
->fmt_in
.p_extra
,
283 p_dec
->fmt_in
.i_extra
);
285 while( ( p_pic
= Packetize( p_dec
, &p_init
) ) )
287 /* Should not occur because we should only receive SPS/PPS */
288 block_Release( p_pic
);
296 /*****************************************************************************
297 * Close: clean up the packetizer
298 *****************************************************************************/
299 static void Close( vlc_object_t
*p_this
)
301 decoder_t
*p_dec
= (decoder_t
*)p_this
;
302 decoder_sys_t
*p_sys
= p_dec
->p_sys
;
304 if( p_sys
->p_frame
) block_ChainRelease( p_sys
->p_frame
);
305 if( p_sys
->p_sps
) block_Release( p_sys
->p_sps
);
306 if( p_sys
->p_pps
) block_Release( p_sys
->p_pps
);
307 block_BytestreamRelease( &p_sys
->bytestream
);
311 /****************************************************************************
312 * Packetize: the whole thing
313 * Search for the startcodes 3 or more bytes
314 * Feed ParseNALBlock ALWAYS with 4 byte startcode prepended NALs
315 ****************************************************************************/
316 static block_t
*Packetize( decoder_t
*p_dec
, block_t
**pp_block
)
318 decoder_sys_t
*p_sys
= p_dec
->p_sys
;
321 if( !pp_block
|| !*pp_block
)
324 if( (*pp_block
)->i_flags
&(BLOCK_FLAG_DISCONTINUITY
|BLOCK_FLAG_CORRUPTED
) )
326 if( (*pp_block
)->i_flags
&BLOCK_FLAG_CORRUPTED
)
328 p_sys
->i_state
= STATE_NOSYNC
;
329 block_BytestreamFlush( &p_sys
->bytestream
);
332 block_ChainRelease( p_sys
->p_frame
);
333 p_sys
->p_frame
= NULL
;
334 p_sys
->slice
.i_frame_type
= 0;
335 p_sys
->b_slice
= VLC_FALSE
;
337 block_Release( *pp_block
);
341 block_BytestreamPush( &p_sys
->bytestream
, *pp_block
);
345 switch( p_sys
->i_state
)
348 /* Skip until 3 byte startcode 0 0 1 */
349 if( block_FindStartcodeFromOffset( &p_sys
->bytestream
,
350 &p_sys
->i_offset
, p_sys
->startcode
+1, 3 ) == VLC_SUCCESS
)
352 p_sys
->i_state
= STATE_NEXT_SYNC
;
355 if( p_sys
->i_offset
)
358 block_SkipBytes( &p_sys
->bytestream
, p_sys
->i_offset
);
360 block_BytestreamFlush( &p_sys
->bytestream
);
363 if( p_sys
->i_state
!= STATE_NEXT_SYNC
)
369 p_sys
->i_offset
= 1; /* To find next startcode */
371 case STATE_NEXT_SYNC
:
372 /* Find the next 3 byte startcode 0 0 1*/
373 if( block_FindStartcodeFromOffset( &p_sys
->bytestream
,
374 &p_sys
->i_offset
, p_sys
->startcode
+1, 3 ) != VLC_SUCCESS
)
380 /* Get the new fragment and set the pts/dts */
381 p_pic
= block_New( p_dec
, p_sys
->i_offset
+1 );
382 p_pic
->i_pts
= p_sys
->bytestream
.p_block
->i_pts
;
383 p_pic
->i_dts
= p_sys
->bytestream
.p_block
->i_dts
;
384 /* Force 4 byte startcode 0 0 0 1 */
385 p_pic
->p_buffer
[0] = 0;
387 block_GetBytes( &p_sys
->bytestream
, &p_pic
->p_buffer
[1],
390 /* Remove trailing 0 bytes */
391 while( p_pic
->i_buffer
&& (!p_pic
->p_buffer
[p_pic
->i_buffer
-1] ) )
396 if( !( p_pic
= ParseNALBlock( p_dec
, p_pic
) ) )
398 p_sys
->i_state
= STATE_NOSYNC
;
402 msg_Dbg( p_dec
, "pts="I64Fd
" dts="I64Fd
,
403 p_pic
->i_pts
, p_pic
->i_dts
);
406 /* So p_block doesn't get re-added several times */
407 *pp_block
= block_BytestreamPop( &p_sys
->bytestream
);
409 p_sys
->i_state
= STATE_NOSYNC
;
416 /****************************************************************************
417 * PacketizeAVC1: Takes VCL blocks of data and creates annexe B type NAL stream
418 * Will always use 4 byte 0 0 0 1 startcodes
419 * Will prepend a SPS and PPS before each keyframe
420 ****************************************************************************/
421 static block_t
*PacketizeAVC1( decoder_t
*p_dec
, block_t
**pp_block
)
423 decoder_sys_t
*p_sys
= p_dec
->p_sys
;
425 block_t
*p_ret
= NULL
;
428 if( !pp_block
|| !*pp_block
)
430 if( (*pp_block
)->i_flags
&(BLOCK_FLAG_DISCONTINUITY
|BLOCK_FLAG_CORRUPTED
) )
432 block_Release( *pp_block
);
439 for( p
= p_block
->p_buffer
; p
< &p_block
->p_buffer
[p_block
->i_buffer
]; )
445 for( i
= 0; i
< p_sys
->i_avcC_length_size
; i
++ )
447 i_size
= (i_size
<< 8) | (*p
++);
452 block_t
*p_part
= nal_get_annexeb( p_dec
, p
, i_size
);
454 p_part
->i_dts
= p_block
->i_dts
;
455 p_part
->i_pts
= p_block
->i_pts
;
458 if( ( p_pic
= ParseNALBlock( p_dec
, p_part
) ) )
460 block_ChainAppend( &p_ret
, p_pic
);
465 block_Release( p_block
);
470 static block_t
*nal_get_annexeb( decoder_t
*p_dec
, uint8_t *p
, int i_size
)
474 p_nal
= block_New( p_dec
, 4 + i_size
);
477 p_nal
->p_buffer
[0] = 0x00;
478 p_nal
->p_buffer
[1] = 0x00;
479 p_nal
->p_buffer
[2] = 0x00;
480 p_nal
->p_buffer
[3] = 0x01;
483 memcpy( &p_nal
->p_buffer
[4], p
, i_size
);
488 static void nal_get_decoded( uint8_t **pp_ret
, int *pi_ret
,
489 uint8_t *src
, int i_src
)
491 uint8_t *end
= &src
[i_src
];
492 uint8_t *dst
= malloc( i_src
);
500 if( src
< end
- 3 && src
[0] == 0x00 && src
[1] == 0x00 &&
512 *pi_ret
= dst
- *pp_ret
;
515 static inline int bs_read_ue( bs_t
*s
)
519 while( bs_read1( s
) == 0 && s
->p
< s
->p_end
&& i
< 32 )
523 return( ( 1 << i
) - 1 + bs_read( s
, i
) );
526 static inline int bs_read_se( bs_t
*s
)
528 int val
= bs_read_ue( s
);
530 return val
&0x01 ? (val
+1)/2 : -(val
/2);
533 /*****************************************************************************
534 * ParseNALBlock: parses annexB type NALs
535 * All p_frag blocks are required to start with 0 0 0 1 4-byte startcode
536 *****************************************************************************/
537 static block_t
*ParseNALBlock( decoder_t
*p_dec
, block_t
*p_frag
)
539 decoder_sys_t
*p_sys
= p_dec
->p_sys
;
540 block_t
*p_pic
= NULL
;
542 const int i_nal_ref_idc
= (p_frag
->p_buffer
[4] >> 5)&0x03;
543 const int i_nal_type
= p_frag
->p_buffer
[4]&0x1f;
547 if( !p_sys->b_header && p_sys->slice.i_frame_type != BLOCK_FLAG_TYPE_I) \
550 if( p_sys->slice.i_frame_type == BLOCK_FLAG_TYPE_I && p_sys->p_sps && p_sys->p_pps ) \
552 block_t *p_sps = block_Duplicate( p_sys->p_sps ); \
553 block_t *p_pps = block_Duplicate( p_sys->p_pps ); \
554 p_sps->i_dts = p_sys->p_frame->i_dts; \
555 p_sps->i_pts = p_sys->p_frame->i_pts; \
556 block_ChainAppend( &p_sps, p_pps ); \
557 block_ChainAppend( &p_sps, p_sys->p_frame ); \
558 p_sys->b_header = VLC_TRUE; \
559 p_pic = block_ChainGather( p_sps ); \
561 p_pic = block_ChainGather( p_sys->p_frame ); \
563 p_pic->i_length = 0; /* FIXME */ \
564 p_pic->i_flags |= p_sys->slice.i_frame_type; \
566 p_sys->slice.i_frame_type = 0; \
567 p_sys->p_frame = NULL; \
568 p_sys->b_slice = VLC_FALSE; \
571 if( p_sys
->b_slice
&& ( !p_sys
->b_sps
|| !p_sys
->b_pps
) )
573 block_ChainRelease( p_sys
->p_frame
);
574 msg_Warn( p_dec
, "waiting for SPS/PPS" );
577 p_sys
->slice
.i_frame_type
= 0;
578 p_sys
->p_frame
= NULL
;
579 p_sys
->b_slice
= VLC_FALSE
;
582 if( ( !p_sys
->b_sps
|| !p_sys
->b_pps
) &&
583 i_nal_type
>= NAL_SLICE
&& i_nal_type
<= NAL_SLICE_IDR
)
585 p_sys
->b_slice
= VLC_TRUE
;
586 /* Fragment will be discarded later on */
588 else if( i_nal_type
>= NAL_SLICE
&& i_nal_type
<= NAL_SLICE_IDR
)
591 int i_dec
= 0, i_first_mb
, i_slice_type
;
596 /* do not convert the whole frame */
597 nal_get_decoded( &dec
, &i_dec
, &p_frag
->p_buffer
[5],
598 __MIN( p_frag
->i_buffer
- 5, 60 ) );
599 bs_init( &s
, dec
, i_dec
);
601 /* first_mb_in_slice */
602 i_first_mb
= bs_read_ue( &s
);
605 switch( (i_slice_type
= bs_read_ue( &s
)) )
608 slice
.i_frame_type
= BLOCK_FLAG_TYPE_P
;
611 slice
.i_frame_type
= BLOCK_FLAG_TYPE_B
;
614 slice
.i_frame_type
= BLOCK_FLAG_TYPE_I
;
616 case 3: case 8: /* SP */
617 slice
.i_frame_type
= BLOCK_FLAG_TYPE_P
;
620 slice
.i_frame_type
= BLOCK_FLAG_TYPE_I
;
623 slice
.i_frame_type
= 0;
628 slice
.i_nal_type
= i_nal_type
;
629 slice
.i_nal_ref_idc
= i_nal_ref_idc
;
631 slice
.i_pic_parameter_set_id
= bs_read_ue( &s
);
632 slice
.i_frame_num
= bs_read( &s
, p_sys
->i_log2_max_frame_num
+ 4 );
634 slice
.i_field_pic_flag
= 0;
635 slice
.i_bottom_field_flag
= -1;
636 if( !p_sys
->b_frame_mbs_only
)
639 slice
.i_field_pic_flag
= bs_read( &s
, 1 );
640 if( slice
.i_field_pic_flag
)
641 slice
.i_bottom_field_flag
= bs_read( &s
, 1 );
644 slice
.i_idr_pic_id
= p_sys
->slice
.i_idr_pic_id
;
645 if( slice
.i_nal_type
== NAL_SLICE_IDR
)
646 slice
.i_idr_pic_id
= bs_read_ue( &s
);
648 slice
.i_pic_order_cnt_lsb
= -1;
649 slice
.i_delta_pic_order_cnt_bottom
= -1;
650 slice
.i_delta_pic_order_cnt0
= 0;
651 slice
.i_delta_pic_order_cnt1
= 0;
652 if( p_sys
->i_pic_order_cnt_type
== 0 )
654 slice
.i_pic_order_cnt_lsb
= bs_read( &s
, p_sys
->i_log2_max_pic_order_cnt_lsb
+ 4 );
655 if( p_sys
->i_pic_order_present_flag
&& !slice
.i_field_pic_flag
)
656 slice
.i_delta_pic_order_cnt_bottom
= bs_read_se( &s
);
658 else if( (p_sys
->i_pic_order_cnt_type
== 1) &&
659 (!p_sys
->i_delta_pic_order_always_zero_flag
) )
661 slice
.i_delta_pic_order_cnt0
= bs_read_se( &s
);
662 if( p_sys
->i_pic_order_present_flag
&& !slice
.i_field_pic_flag
)
663 slice
.i_delta_pic_order_cnt1
= bs_read_se( &s
);
666 /* Detection of the first VCL NAL unit of a primary coded picture
669 if( slice
.i_frame_num
!= p_sys
->slice
.i_frame_num
||
670 slice
.i_pic_parameter_set_id
!= p_sys
->slice
.i_pic_parameter_set_id
||
671 slice
.i_field_pic_flag
!= p_sys
->slice
.i_field_pic_flag
||
672 slice
.i_nal_ref_idc
!= p_sys
->slice
.i_nal_ref_idc
)
674 if( (slice
.i_bottom_field_flag
!= -1) &&
675 (p_sys
->slice
.i_bottom_field_flag
!= -1) &&
676 (slice
.i_bottom_field_flag
!= p_sys
->slice
.i_bottom_field_flag
) )
678 if( p_sys
->i_pic_order_cnt_type
== 0 &&
679 ( slice
.i_pic_order_cnt_lsb
!= p_sys
->slice
.i_pic_order_cnt_lsb
||
680 slice
.i_delta_pic_order_cnt_bottom
!= p_sys
->slice
.i_delta_pic_order_cnt_bottom
) )
682 else if( p_sys
->i_pic_order_cnt_type
== 1 &&
683 ( slice
.i_delta_pic_order_cnt0
!= p_sys
->slice
.i_delta_pic_order_cnt0
||
684 slice
.i_delta_pic_order_cnt1
!= p_sys
->slice
.i_delta_pic_order_cnt1
) )
686 if( ( slice
.i_nal_type
== NAL_SLICE_IDR
|| p_sys
->slice
.i_nal_type
== NAL_SLICE_IDR
) &&
687 ( slice
.i_nal_type
!= p_sys
->slice
.i_nal_type
|| slice
.i_idr_pic_id
!= p_sys
->slice
.i_idr_pic_id
) )
691 p_sys
->slice
= slice
;
693 if( b_pic
&& p_sys
->b_slice
)
696 p_sys
->b_slice
= VLC_TRUE
;
700 else if( i_nal_type
== NAL_SPS
)
707 if( !p_sys
->b_sps
) msg_Dbg( p_dec
, "found NAL_SPS" );
709 p_sys
->b_sps
= VLC_TRUE
;
711 nal_get_decoded( &dec
, &i_dec
, &p_frag
->p_buffer
[5],
712 p_frag
->i_buffer
- 5 );
714 bs_init( &s
, dec
, i_dec
);
715 /* Skip profile(8), constraint_set012, reserver(5), level(8) */
716 bs_skip( &s
, 8 + 1+1+1 + 5 + 8 );
719 /* Skip i_log2_max_frame_num */
720 p_sys
->i_log2_max_frame_num
= bs_read_ue( &s
);
721 if( p_sys
->i_log2_max_frame_num
> 12)
722 p_sys
->i_log2_max_frame_num
= 12;
724 p_sys
->i_pic_order_cnt_type
= bs_read_ue( &s
);
725 if( p_sys
->i_pic_order_cnt_type
== 0 )
727 /* skip i_log2_max_poc_lsb */
728 p_sys
->i_log2_max_pic_order_cnt_lsb
= bs_read_ue( &s
);
729 if( p_sys
->i_log2_max_pic_order_cnt_lsb
> 12 )
730 p_sys
->i_log2_max_pic_order_cnt_lsb
= 12;
732 else if( p_sys
->i_pic_order_cnt_type
== 1 )
735 /* skip b_delta_pic_order_always_zero */
736 p_sys
->i_delta_pic_order_always_zero_flag
= bs_read( &s
, 1 );
737 /* skip i_offset_for_non_ref_pic */
739 /* skip i_offset_for_top_to_bottom_field */
741 /* read i_num_ref_frames_in_poc_cycle */
742 i_cycle
= bs_read_ue( &s
);
743 if( i_cycle
> 256 ) i_cycle
= 256;
746 /* skip i_offset_for_ref_frame */
750 /* i_num_ref_frames */
752 /* b_gaps_in_frame_num_value_allowed */
756 p_dec
->fmt_out
.video
.i_width
= 16 * ( bs_read_ue( &s
) + 1 );
757 p_dec
->fmt_out
.video
.i_height
= 16 * ( bs_read_ue( &s
) + 1 );
759 /* b_frame_mbs_only */
760 p_sys
->b_frame_mbs_only
= bs_read( &s
, 1 );
761 if( p_sys
->b_frame_mbs_only
== 0 )
765 /* b_direct8x8_inference */
769 i_tmp
= bs_read( &s
, 1 );
783 i_tmp
= bs_read( &s
, 1 );
786 /* read the aspect ratio part if any FIXME check it */
787 i_tmp
= bs_read( &s
, 1 );
790 static const struct { int w
, h
; } sar
[14] =
792 { 0, 0 }, { 1, 1 }, { 12, 11 }, { 10, 11 },
793 { 16, 11 }, { 40, 33 }, { 24, 11 }, { 20, 11 },
794 { 32, 11 }, { 80, 33 }, { 18, 11 }, { 15, 11 },
795 { 64, 33 }, { 160,99 },
797 int i_sar
= bs_read( &s
, 8 );
807 w
= bs_read( &s
, 16 );
808 h
= bs_read( &s
, 16 );
811 p_dec
->fmt_out
.video
.i_aspect
= VOUT_ASPECT_FACTOR
* w
/
812 h
* p_dec
->fmt_out
.video
.i_width
/
813 p_dec
->fmt_out
.video
.i_height
;
815 p_dec
->fmt_out
.video
.i_aspect
= VOUT_ASPECT_FACTOR
;
821 if( p_sys
->b_slice
) OUTPUT
;
823 /* We have a new SPS */
824 if( p_sys
->p_sps
) block_Release( p_sys
->p_sps
);
825 p_sys
->p_sps
= p_frag
;
827 /* Do not append the SPS because we will insert it on keyframes */
830 else if( i_nal_type
== NAL_PPS
)
834 bs_init( &s
, &p_frag
->p_buffer
[5], p_frag
->i_buffer
- 5 );
835 bs_read_ue( &s
); // pps id
836 bs_read_ue( &s
); // sps id
837 bs_skip( &s
, 1 ); // entropy coding mode flag
838 p_sys
->i_pic_order_present_flag
= bs_read( &s
, 1 );
840 if( !p_sys
->b_pps
) msg_Dbg( p_dec
, "found NAL_PPS" );
841 p_sys
->b_pps
= VLC_TRUE
;
845 if( p_sys
->b_slice
) OUTPUT
;
847 /* We have a new PPS */
848 if( p_sys
->p_pps
) block_Release( p_sys
->p_pps
);
849 p_sys
->p_pps
= p_frag
;
851 /* Do not append the PPS because we will insert it on keyframes */
854 else if( i_nal_type
== NAL_AU_DELIMITER
||
855 i_nal_type
== NAL_SEI
||
856 ( i_nal_type
>= 13 && i_nal_type
<= 18 ) )
858 if( p_sys
->b_slice
) OUTPUT
;
863 /* Append the block */
864 block_ChainAppend( &p_sys
->p_frame
, p_frag
);