X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fpacketizer%2Fh264.c;h=79f5f53e5410fc300e2650f64ec3aba5c8e7dac3;hb=7d1d56fec646569bd14262f6b9dde31becbe2137;hp=dfffbc7cfe749f77a3487458aa5b4e275397da83;hpb=e3576569c7c8d85bef4376785464ca6ed2172cff;p=vlc diff --git a/modules/packetizer/h264.c b/modules/packetizer/h264.c index dfffbc7cfe..79f5f53e54 100644 --- a/modules/packetizer/h264.c +++ b/modules/packetizer/h264.c @@ -1,12 +1,13 @@ /***************************************************************************** * h264.c: h264/avc video packetizer ***************************************************************************** - * Copyright (C) 2001, 2002 VideoLAN + * Copyright (C) 2001, 2002, 2006 the VideoLAN team * $Id$ * * Authors: Laurent Aimar * Eric Petit - * Gildas Bazin + * Gildas Bazin + * Derk-Jan Hartman * * 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 @@ -20,17 +21,22 @@ * * 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., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** * Preamble *****************************************************************************/ -#include /* malloc(), free() */ -#include -#include -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include +#include +#include +#include #include "vlc_block_helper.h" #include "vlc_bits.h" @@ -42,7 +48,9 @@ static int Open ( vlc_object_t * ); static void Close( vlc_object_t * ); vlc_module_begin(); - set_description( _("H264 video packetizer") ); + set_category( CAT_SOUT ); + set_subcategory( SUBCAT_SOUT_PACKETIZER ); + set_description( N_("H.264 video packetizer") ); set_capability( "packetizer", 50 ); set_callbacks( Open, Close ); vlc_module_end(); @@ -54,25 +62,59 @@ vlc_module_end(); static block_t *Packetize( decoder_t *, block_t ** ); static block_t *PacketizeAVC1( decoder_t *, block_t ** ); +typedef struct +{ + int i_nal_type; + int i_nal_ref_idc; + + int i_frame_type; + int i_pic_parameter_set_id; + int i_frame_num; + + int i_field_pic_flag; + int i_bottom_field_flag; + + int i_idr_pic_id; + + int i_pic_order_cnt_lsb; + int i_delta_pic_order_cnt_bottom; + + int i_delta_pic_order_cnt0; + int i_delta_pic_order_cnt1; +} slice_t; + struct decoder_sys_t { block_bytestream_t bytestream; int i_state; - int i_offset; + size_t i_offset; uint8_t startcode[4]; - vlc_bool_t b_slice; + bool b_slice; block_t *p_frame; - int64_t i_dts; - int64_t i_pts; - unsigned int i_flags; - - vlc_bool_t b_sps; + bool b_sps; + bool b_pps; + bool b_header; /* avcC data */ int i_avcC_length_size; + block_t *p_sps; + block_t *p_pps; + + /* Useful values of the Sequence Parameter Set */ + int i_log2_max_frame_num; + int b_frame_mbs_only; + int i_pic_order_cnt_type; + int i_delta_pic_order_always_zero_flag; + int i_log2_max_pic_order_cnt_lsb; + + /* Value from Picture Parameter Set */ + int i_pic_order_present_flag; + + /* Useful values of the Slice Header */ + slice_t slice; }; enum @@ -91,7 +133,8 @@ enum nal_unit_type_e NAL_SLICE_IDR = 5, /* ref_idc != 0 */ NAL_SEI = 6, /* ref_idc == 0 */ NAL_SPS = 7, - NAL_PPS = 8 + NAL_PPS = 8, + NAL_AU_DELIMITER= 9 /* ref_idc == 0 for 6,9,10,11,12 */ }; @@ -105,10 +148,12 @@ enum nal_priority_e static block_t *ParseNALBlock( decoder_t *, block_t * ); -static block_t *nal_get_encoded( decoder_t *, uint8_t *p, int ); +static block_t *nal_get_annexeb( decoder_t *, uint8_t *p, int ); /***************************************************************************** * Open: probe the packetizer and return score + * When opening after demux, the packetizer is only loaded AFTER the decoder + * That means that what you set in fmt_out is ignored by the decoder in this special case *****************************************************************************/ static int Open( vlc_object_t *p_this ) { @@ -117,7 +162,11 @@ static int Open( vlc_object_t *p_this ) if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'h', '2', '6', '4') && p_dec->fmt_in.i_codec != VLC_FOURCC( 'H', '2', '6', '4') && - ( p_dec->fmt_in.i_codec != VLC_FOURCC( 'a', 'v', 'c', '1') || p_dec->fmt_in.i_extra < 7 ) ) + p_dec->fmt_in.i_codec != VLC_FOURCC( 'V', 'S', 'S', 'H') && + p_dec->fmt_in.i_codec != VLC_FOURCC( 'v', 's', 's', 'h') && + p_dec->fmt_in.i_codec != VLC_FOURCC( 'D', 'A', 'V', 'C') && + ( p_dec->fmt_in.i_codec != VLC_FOURCC( 'a', 'v', 'c', '1') || + p_dec->fmt_in.i_extra < 7 ) ) { return VLC_EGENERIC; } @@ -125,8 +174,7 @@ static int Open( vlc_object_t *p_this ) /* Allocate the memory needed to store the decoder's structure */ if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == NULL ) { - msg_Err( p_dec, "out of memory" ); - return VLC_EGENERIC; + return VLC_ENOMEM; } p_sys->i_state = STATE_NOSYNC; p_sys->i_offset = 0; @@ -134,13 +182,25 @@ static int Open( vlc_object_t *p_this ) p_sys->startcode[1] = 0; p_sys->startcode[2] = 0; p_sys->startcode[3] = 1; - p_sys->bytestream = block_BytestreamInit( p_dec ); - p_sys->b_slice = VLC_FALSE; + p_sys->bytestream = block_BytestreamInit(); + p_sys->b_slice = false; p_sys->p_frame = NULL; - p_sys->i_dts = 0; - p_sys->i_pts = 0; - p_sys->i_flags = 0; - p_sys->b_sps = VLC_FALSE; + p_sys->b_sps = false; + p_sys->b_pps = false; + p_sys->p_sps = 0; + p_sys->p_pps = 0; + p_sys->b_header= false; + + p_sys->slice.i_nal_type = -1; + p_sys->slice.i_nal_ref_idc = -1; + p_sys->slice.i_idr_pic_id = -1; + p_sys->slice.i_frame_num = -1; + p_sys->slice.i_frame_type = 0; + p_sys->slice.i_pic_parameter_set_id = -1; + p_sys->slice.i_field_pic_flag = 0; + p_sys->slice.i_bottom_field_flag = -1; + p_sys->slice.i_pic_order_cnt_lsb = -1; + p_sys->slice.i_delta_pic_order_cnt_bottom = -1; /* Setup properties */ es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in ); @@ -148,6 +208,10 @@ static int Open( vlc_object_t *p_this ) if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'a', 'v', 'c', '1' ) ) { + /* This type of stream is produced by mp4 and matroska + * when we want to store it in another streamformat, you need to convert + * The fmt_in.p_extra should ALWAYS contain the avcC + * The fmt_out.p_extra should contain all the SPS and PPS with 4 byte startcodes */ uint8_t *p = &((uint8_t*)p_dec->fmt_in.p_extra)[4]; int i_sps, i_pps; int i; @@ -157,35 +221,88 @@ static int Open( vlc_object_t *p_this ) /* Read SPS */ i_sps = (*p++)&0x1f; - for( i = 0; i < i_sps; i++ ) { - int i_length = GetWBE( p ); - block_t *p_sps = nal_get_encoded( p_dec, p+2, i_length ); - + uint16_t i_length = GetWBE( p ); p += 2; + if( i_length > + (uint8_t*)p_dec->fmt_in.p_extra + p_dec->fmt_in.i_extra - p ) + { + return VLC_EGENERIC; + } + block_t *p_sps = nal_get_annexeb( p_dec, p, i_length ); + if( !p_sps ) + return VLC_EGENERIC; + p_sys->p_sps = block_Duplicate( p_sps ); + p_sps->i_pts = p_sps->i_dts = mdate(); ParseNALBlock( p_dec, p_sps ); - p += 2 + i_length; + p += i_length; } /* Read PPS */ i_pps = *p++; for( i = 0; i < i_pps; i++ ) { - int i_length = GetWBE( p ); - block_t *p_pps = nal_get_encoded( p_dec, p+2, i_length ); - + uint16_t i_length = GetWBE( p ); p += 2; + if( i_length > + (uint8_t*)p_dec->fmt_in.p_extra + p_dec->fmt_in.i_extra - p ) + { + return VLC_EGENERIC; + } + block_t *p_pps = nal_get_annexeb( p_dec, p, i_length ); + if( !p_pps ) + return VLC_EGENERIC; + p_sys->p_pps = block_Duplicate( p_pps ); + p_pps->i_pts = p_pps->i_dts = mdate(); ParseNALBlock( p_dec, p_pps ); - p += 2 + i_length; + p += i_length; } - msg_Dbg( p_dec, "avcC length size=%d sps=%d pps=%d", + msg_Dbg( p_dec, "avcC length size=%d, sps=%d, pps=%d", p_sys->i_avcC_length_size, i_sps, i_pps ); + /* FIXME: FFMPEG isn't happy at all if you leave this */ + if( p_dec->fmt_out.i_extra > 0 ) free( p_dec->fmt_out.p_extra ); + p_dec->fmt_out.i_extra = 0; + p_dec->fmt_out.p_extra = NULL; + + /* Set the new extradata */ + p_dec->fmt_out.i_extra = p_sys->p_pps->i_buffer + p_sys->p_sps->i_buffer; + p_dec->fmt_out.p_extra = malloc( p_dec->fmt_out.i_extra ); + if( p_dec->fmt_out.p_extra ) + { + memcpy( (uint8_t*)p_dec->fmt_out.p_extra, + p_sys->p_sps->p_buffer, p_sys->p_sps->i_buffer); + 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); + p_sys->b_header = true; + } + else p_dec->fmt_out.i_extra = 0; + /* Set callback */ p_dec->pf_packetize = PacketizeAVC1; } else { + /* This type of stream contains data with 3 of 4 byte startcodes + * The fmt_in.p_extra MAY contain SPS/PPS with 4 byte startcodes + * The fmt_out.p_extra should be the same */ + /* Set callback */ p_dec->pf_packetize = Packetize; + + /* */ + 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 ) ) ) + { + /* Should not occur because we should only receive SPS/PPS */ + block_Release( p_pic ); + } + } } return VLC_SUCCESS; @@ -199,19 +316,42 @@ 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; + if( p_sys->p_frame ) block_ChainRelease( p_sys->p_frame ); + if( p_sys->p_sps ) block_Release( p_sys->p_sps ); + if( p_sys->p_pps ) block_Release( p_sys->p_pps ); block_BytestreamRelease( &p_sys->bytestream ); free( p_sys ); } /**************************************************************************** * Packetize: the whole thing + * Search for the startcodes 3 or more bytes + * Feed ParseNALBlock ALWAYS with 4 byte startcode prepended NALs ****************************************************************************/ 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 || !*pp_block ) return NULL; + if( !pp_block || !*pp_block ) + return NULL; + + if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) ) + { + if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED ) + { + p_sys->i_state = STATE_NOSYNC; + block_BytestreamFlush( &p_sys->bytestream ); + + if( p_sys->p_frame ) + block_ChainRelease( p_sys->p_frame ); + p_sys->p_frame = NULL; + p_sys->slice.i_frame_type = 0; + p_sys->b_slice = false; + } + block_Release( *pp_block ); + return NULL; + } block_BytestreamPush( &p_sys->bytestream, *pp_block ); @@ -220,14 +360,16 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block ) switch( p_sys->i_state ) { case STATE_NOSYNC: + /* Skip until 3 byte startcode 0 0 1 */ if( block_FindStartcodeFromOffset( &p_sys->bytestream, - &p_sys->i_offset, p_sys->startcode, 4 ) == VLC_SUCCESS ) + &p_sys->i_offset, p_sys->startcode+1, 3 ) == VLC_SUCCESS) { p_sys->i_state = STATE_NEXT_SYNC; } if( p_sys->i_offset ) { + /* skip the data */ block_SkipBytes( &p_sys->bytestream, p_sys->i_offset ); p_sys->i_offset = 0; block_BytestreamFlush( &p_sys->bytestream ); @@ -242,22 +384,27 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block ) p_sys->i_offset = 1; /* To find next startcode */ case STATE_NEXT_SYNC: - /* Find the next startcode */ + /* Find the next 3 byte startcode 0 0 1*/ if( block_FindStartcodeFromOffset( &p_sys->bytestream, - &p_sys->i_offset, p_sys->startcode, 4 ) != VLC_SUCCESS ) + &p_sys->i_offset, p_sys->startcode+1, 3 ) != VLC_SUCCESS) { /* Need more data */ return NULL; } /* Get the new fragment and set the pts/dts */ - p_pic = block_New( p_dec, p_sys->i_offset ); + p_pic = block_New( p_dec, p_sys->i_offset +1 ); p_pic->i_pts = p_sys->bytestream.p_block->i_pts; p_pic->i_dts = p_sys->bytestream.p_block->i_dts; + /* Force 4 byte startcode 0 0 0 1 */ + p_pic->p_buffer[0] = 0; - block_GetBytes( &p_sys->bytestream, p_pic->p_buffer, - p_pic->i_buffer ); + block_GetBytes( &p_sys->bytestream, &p_pic->p_buffer[1], + p_pic->i_buffer-1 ); + /* Remove trailing 0 bytes */ + while( p_pic->i_buffer && (!p_pic->p_buffer[p_pic->i_buffer-1] ) ) + p_pic->i_buffer--; p_sys->i_offset = 0; /* Parse the NAL */ @@ -266,6 +413,10 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block ) p_sys->i_state = STATE_NOSYNC; break; } +#if 0 + msg_Dbg( p_dec, "pts=%"PRId64" dts=%"PRId64, + p_pic->i_pts, p_pic->i_dts ); +#endif /* So p_block doesn't get re-added several times */ *pp_block = block_BytestreamPop( &p_sys->bytestream ); @@ -278,7 +429,9 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block ) } /**************************************************************************** - * PacketizeAVC1: the whole thing + * PacketizeAVC1: Takes VCL blocks of data and creates annexe B type NAL stream + * Will always use 4 byte 0 0 0 1 startcodes + * Will prepend a SPS and PPS before each keyframe ****************************************************************************/ static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block ) { @@ -287,7 +440,13 @@ static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block ) block_t *p_ret = NULL; uint8_t *p; - if( !pp_block || !*pp_block ) return NULL; + if( !pp_block || !*pp_block ) + return NULL; + if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) ) + { + block_Release( *pp_block ); + return NULL; + } p_block = *pp_block; *pp_block = NULL; @@ -303,109 +462,74 @@ static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block ) i_size = (i_size << 8) | (*p++); } - if( i_size > 0 ) + if( i_size <= 0 || + i_size > ( p_block->p_buffer + p_block->i_buffer - p ) ) { - block_t *p_part = nal_get_encoded( p_dec, p, i_size ); + msg_Err( p_dec, "Broken frame : size %d is too big", i_size ); + break; + } - p_part->i_dts = p_block->i_dts; - p_part->i_pts = p_block->i_pts; - /* Parse the NAL */ - if( ( p_pic = ParseNALBlock( p_dec, p_part ) ) ) - { - block_ChainAppend( &p_ret, p_pic ); - } + block_t *p_part = nal_get_annexeb( p_dec, p, i_size ); + if( !p_part ) + break; + p_part->i_dts = p_block->i_dts; + p_part->i_pts = p_block->i_pts; + + /* Parse the NAL */ + if( ( p_pic = ParseNALBlock( p_dec, p_part ) ) ) + { + block_ChainAppend( &p_ret, p_pic ); } p += i_size; } + block_Release( p_block ); return p_ret; } -static block_t *nal_get_encoded( decoder_t *p_dec, uint8_t *p, int i_size ) +static block_t *nal_get_annexeb( decoder_t *p_dec, uint8_t *p, int i_size ) { block_t *p_nal; - int i_nal_size = 5; - uint8_t *src = &p[1]; - uint8_t *end = &p[i_size]; - uint8_t *dst; - int i_count = 0; - - /* 1: compute real size */ - while( src < end ) - { - if( i_count == 2 && *src <= 0x03 ) - { - i_nal_size++; - i_count = 0; - } - if( *src == 0 ) - { - i_count++; - } - else - { - i_count = 0; - } - i_nal_size++; - src++; - } - - /* 2: encode it */ - p_nal = block_New( p_dec, i_nal_size ); - i_count = 0; - src = p; - dst = p_nal->p_buffer; - /* add start code */ - *dst++ = 0x00; - *dst++ = 0x00; - *dst++ = 0x00; - *dst++ = 0x01; + p_nal = block_New( p_dec, 4 + i_size ); + if( !p_nal ) return NULL; - /* nal type */ - *dst++ = *src++; + /* Add start code */ + p_nal->p_buffer[0] = 0x00; + p_nal->p_buffer[1] = 0x00; + p_nal->p_buffer[2] = 0x00; + p_nal->p_buffer[3] = 0x01; - while( src < end ) - { - if( i_count == 2 && *src <= 0x03 ) - { - *dst++ = 0x03; - i_count = 0; - } - if( *src == 0 ) - { - i_count++; - } - else - { - i_count = 0; - } - *dst++ = *src++; - } + /* Copy nalu */ + memcpy( &p_nal->p_buffer[4], p, i_size ); return p_nal; } -static void nal_get_decoded( uint8_t **pp_ret, int *pi_ret, uint8_t *src, int i_src ) +static void nal_get_decoded( uint8_t **pp_ret, int *pi_ret, + uint8_t *src, int i_src ) { uint8_t *end = &src[i_src]; uint8_t *dst = malloc( i_src ); *pp_ret = dst; - while( src < end ) + if( dst ) { - if( src < end - 3 && src[0] == 0x00 && src[1] == 0x00 && src[2] == 0x03 ) + while( src < end ) { - *dst++ = 0x00; - *dst++ = 0x00; + if( src < end - 3 && src[0] == 0x00 && src[1] == 0x00 && + src[2] == 0x03 ) + { + *dst++ = 0x00; + *dst++ = 0x00; - src += 3; - continue; + src += 3; + continue; + } + *dst++ = *src++; } - *dst++ = *src++; } - *pi_ret = dst - *pp_ret; } @@ -419,6 +543,7 @@ static inline int bs_read_ue( bs_t *s ) } return( ( 1 << i) - 1 + bs_read( s, i ) ); } + static inline int bs_read_se( bs_t *s ) { int val = bs_read_ue( s ); @@ -426,87 +551,186 @@ static inline int bs_read_se( bs_t *s ) return val&0x01 ? (val+1)/2 : -(val/2); } - +/***************************************************************************** + * ParseNALBlock: parses annexB type NALs + * All p_frag blocks are required to start with 0 0 0 1 4-byte startcode + *****************************************************************************/ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag ) { decoder_sys_t *p_sys = p_dec->p_sys; block_t *p_pic = NULL; - const int i_ref_idc = (p_frag->p_buffer[4] >> 5)&0x03; - const int i_nal_type= p_frag->p_buffer[4]&0x1f; - - if( p_sys->b_slice && - ( i_nal_type == NAL_SLICE || i_nal_type == NAL_SLICE_IDR || - i_nal_type == NAL_SLICE_DPC || i_nal_type == NAL_SPS || i_nal_type == NAL_PPS ) ) + const int i_nal_ref_idc = (p_frag->p_buffer[4] >> 5)&0x03; + const int i_nal_type = p_frag->p_buffer[4]&0x1f; + +#define OUTPUT \ + do { \ + if( !p_sys->b_header && p_sys->slice.i_frame_type != BLOCK_FLAG_TYPE_I) \ + break; \ + \ + if( p_sys->slice.i_frame_type == BLOCK_FLAG_TYPE_I && p_sys->p_sps && p_sys->p_pps ) \ + { \ + block_t *p_sps = block_Duplicate( p_sys->p_sps ); \ + block_t *p_pps = block_Duplicate( p_sys->p_pps ); \ + p_sps->i_dts = p_sys->p_frame->i_dts; \ + p_sps->i_pts = p_sys->p_frame->i_pts; \ + block_ChainAppend( &p_sps, p_pps ); \ + block_ChainAppend( &p_sps, p_sys->p_frame ); \ + p_sys->b_header = true; \ + p_pic = block_ChainGather( p_sps ); \ + } else { \ + p_pic = block_ChainGather( p_sys->p_frame ); \ + } \ + p_pic->i_length = 0; /* FIXME */ \ + p_pic->i_flags |= p_sys->slice.i_frame_type; \ + \ + p_sys->slice.i_frame_type = 0; \ + p_sys->p_frame = NULL; \ + p_sys->b_slice = false; \ + } while(0) + + if( p_sys->b_slice && ( !p_sys->b_sps || !p_sys->b_pps ) ) { - if( p_sys->b_sps ) - { - p_pic = block_ChainGather( p_sys->p_frame ); - p_pic->i_dts = p_sys->i_dts; - p_pic->i_pts = p_sys->i_pts; - p_pic->i_length = 0; /* FIXME */ - p_pic->i_flags = p_sys->i_flags; - } - else - { - block_ChainRelease( p_sys->p_frame ); - msg_Warn( p_dec, "waiting SPS" ); - } + block_ChainRelease( p_sys->p_frame ); + msg_Warn( p_dec, "waiting for SPS/PPS" ); - /* reset context */ + /* Reset context */ + p_sys->slice.i_frame_type = 0; p_sys->p_frame = NULL; - p_sys->b_slice = VLC_FALSE; - //p_sys->i_dts += 40000; + p_sys->b_slice = false; } - if( i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR ) + if( ( !p_sys->b_sps || !p_sys->b_pps ) && + i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR ) { - uint8_t *dec; - int i_dec; + p_sys->b_slice = true; + /* Fragment will be discarded later on */ + } + else if( i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR ) + { + uint8_t *dec = NULL; + int i_dec = 0, i_first_mb, i_slice_type; + slice_t slice; + bool b_pic; bs_t s; - p_sys->b_slice = VLC_TRUE; - p_sys->i_dts = p_frag->i_dts; - p_sys->i_pts = p_frag->i_pts; - /* do not convert the whole frame */ - nal_get_decoded( &dec, &i_dec, &p_frag->p_buffer[5], __MIN( p_frag->i_buffer - 5, 60 ) ); + nal_get_decoded( &dec, &i_dec, &p_frag->p_buffer[5], + __MIN( p_frag->i_buffer - 5, 60 ) ); bs_init( &s, dec, i_dec ); - /* i_first_mb */ - bs_read_ue( &s ); - /* picture type */ - switch( bs_read_ue( &s ) ) + /* first_mb_in_slice */ + i_first_mb = bs_read_ue( &s ); + + /* slice_type */ + switch( (i_slice_type = bs_read_ue( &s )) ) { - case 0: case 5: - p_sys->i_flags = BLOCK_FLAG_TYPE_P; - break; - case 1: case 6: - p_sys->i_flags =BLOCK_FLAG_TYPE_B; - break; - case 2: case 7: - p_sys->i_flags = BLOCK_FLAG_TYPE_I; - break; - case 3: case 8: /* SP */ - p_sys->i_flags = BLOCK_FLAG_TYPE_P; - break; - case 4: case 9: - p_sys->i_flags = BLOCK_FLAG_TYPE_I; - break; + case 0: case 5: + slice.i_frame_type = BLOCK_FLAG_TYPE_P; + break; + case 1: case 6: + slice.i_frame_type = BLOCK_FLAG_TYPE_B; + break; + case 2: case 7: + slice.i_frame_type = BLOCK_FLAG_TYPE_I; + break; + case 3: case 8: /* SP */ + slice.i_frame_type = BLOCK_FLAG_TYPE_P; + break; + case 4: case 9: + slice.i_frame_type = BLOCK_FLAG_TYPE_I; + break; + default: + slice.i_frame_type = 0; + break; } + /* */ + slice.i_nal_type = i_nal_type; + slice.i_nal_ref_idc = i_nal_ref_idc; + + slice.i_pic_parameter_set_id = bs_read_ue( &s ); + slice.i_frame_num = bs_read( &s, p_sys->i_log2_max_frame_num + 4 ); + + slice.i_field_pic_flag = 0; + slice.i_bottom_field_flag = -1; + if( !p_sys->b_frame_mbs_only ) + { + /* field_pic_flag */ + slice.i_field_pic_flag = bs_read( &s, 1 ); + if( slice.i_field_pic_flag ) + slice.i_bottom_field_flag = bs_read( &s, 1 ); + } + + slice.i_idr_pic_id = p_sys->slice.i_idr_pic_id; + if( slice.i_nal_type == NAL_SLICE_IDR ) + slice.i_idr_pic_id = bs_read_ue( &s ); + + slice.i_pic_order_cnt_lsb = -1; + slice.i_delta_pic_order_cnt_bottom = -1; + slice.i_delta_pic_order_cnt0 = 0; + slice.i_delta_pic_order_cnt1 = 0; + if( p_sys->i_pic_order_cnt_type == 0 ) + { + slice.i_pic_order_cnt_lsb = bs_read( &s, p_sys->i_log2_max_pic_order_cnt_lsb + 4 ); + if( p_sys->i_pic_order_present_flag && !slice.i_field_pic_flag ) + slice.i_delta_pic_order_cnt_bottom = bs_read_se( &s ); + } + else if( (p_sys->i_pic_order_cnt_type == 1) && + (!p_sys->i_delta_pic_order_always_zero_flag) ) + { + slice.i_delta_pic_order_cnt0 = bs_read_se( &s ); + if( p_sys->i_pic_order_present_flag && !slice.i_field_pic_flag ) + slice.i_delta_pic_order_cnt1 = bs_read_se( &s ); + } + + /* Detection of the first VCL NAL unit of a primary coded picture + * (cf. 7.4.1.2.4) */ + b_pic = false; + if( slice.i_frame_num != p_sys->slice.i_frame_num || + slice.i_pic_parameter_set_id != p_sys->slice.i_pic_parameter_set_id || + slice.i_field_pic_flag != p_sys->slice.i_field_pic_flag || + slice.i_nal_ref_idc != p_sys->slice.i_nal_ref_idc ) + b_pic = true; + if( (slice.i_bottom_field_flag != -1) && + (p_sys->slice.i_bottom_field_flag != -1) && + (slice.i_bottom_field_flag != p_sys->slice.i_bottom_field_flag) ) + b_pic = true; + if( p_sys->i_pic_order_cnt_type == 0 && + ( slice.i_pic_order_cnt_lsb != p_sys->slice.i_pic_order_cnt_lsb || + slice.i_delta_pic_order_cnt_bottom != p_sys->slice.i_delta_pic_order_cnt_bottom ) ) + b_pic = true; + else if( p_sys->i_pic_order_cnt_type == 1 && + ( slice.i_delta_pic_order_cnt0 != p_sys->slice.i_delta_pic_order_cnt0 || + slice.i_delta_pic_order_cnt1 != p_sys->slice.i_delta_pic_order_cnt1 ) ) + b_pic = true; + if( ( slice.i_nal_type == NAL_SLICE_IDR || p_sys->slice.i_nal_type == NAL_SLICE_IDR ) && + ( slice.i_nal_type != p_sys->slice.i_nal_type || slice.i_idr_pic_id != p_sys->slice.i_idr_pic_id ) ) + b_pic = true; + + /* */ + p_sys->slice = slice; + + if( b_pic && p_sys->b_slice ) + OUTPUT; + + p_sys->b_slice = true; + free( dec ); } else if( i_nal_type == NAL_SPS ) { - uint8_t *dec; - int i_dec; + uint8_t *dec = NULL; + int i_dec = 0; bs_t s; int i_tmp; - p_sys->b_sps = VLC_TRUE; + if( !p_sys->b_sps ) msg_Dbg( p_dec, "found NAL_SPS" ); + + p_sys->b_sps = true; - nal_get_decoded( &dec, &i_dec, &p_frag->p_buffer[5], p_frag->i_buffer - 5 ); + nal_get_decoded( &dec, &i_dec, &p_frag->p_buffer[5], + p_frag->i_buffer - 5 ); bs_init( &s, dec, i_dec ); /* Skip profile(8), constraint_set012, reserver(5), level(8) */ @@ -514,19 +738,23 @@ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag ) /* sps id */ bs_read_ue( &s ); /* Skip i_log2_max_frame_num */ - bs_read_ue( &s ); + p_sys->i_log2_max_frame_num = bs_read_ue( &s ); + if( p_sys->i_log2_max_frame_num > 12) + p_sys->i_log2_max_frame_num = 12; /* Read poc_type */ - i_tmp = bs_read_ue( &s ); - if( i_tmp == 0 ) + p_sys->i_pic_order_cnt_type = bs_read_ue( &s ); + if( p_sys->i_pic_order_cnt_type == 0 ) { /* skip i_log2_max_poc_lsb */ - bs_read_ue( &s ); + p_sys->i_log2_max_pic_order_cnt_lsb = bs_read_ue( &s ); + if( p_sys->i_log2_max_pic_order_cnt_lsb > 12 ) + p_sys->i_log2_max_pic_order_cnt_lsb = 12; } - else if( i_tmp == 1 ) + else if( p_sys->i_pic_order_cnt_type == 1 ) { int i_cycle; /* skip b_delta_pic_order_always_zero */ - bs_skip( &s, 1 ); + p_sys->i_delta_pic_order_always_zero_flag = bs_read( &s, 1 ); /* skip i_offset_for_non_ref_pic */ bs_read_se( &s ); /* skip i_offset_for_top_to_bottom_field */ @@ -550,26 +778,26 @@ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag ) p_dec->fmt_out.video.i_height = 16 * ( bs_read_ue( &s ) + 1 ); /* b_frame_mbs_only */ - i_tmp = bs_read( &s, 1 ); - if( i_tmp == 0 ) + p_sys->b_frame_mbs_only = bs_read( &s, 1 ); + if( p_sys->b_frame_mbs_only == 0 ) { bs_skip( &s, 1 ); } /* b_direct8x8_inference */ bs_skip( &s, 1 ); - /* crop ? */ + /* crop */ i_tmp = bs_read( &s, 1 ); if( i_tmp ) { /* left */ - p_dec->fmt_out.video.i_width -= 2 * bs_read_ue( &s ); + bs_read_ue( &s ); /* right */ - p_dec->fmt_out.video.i_width -= 2 * bs_read_ue( &s ); + bs_read_ue( &s ); /* top */ - p_dec->fmt_out.video.i_height -= 2 * bs_read_ue( &s ); + bs_read_ue( &s ); /* bottom */ - p_dec->fmt_out.video.i_height -= 2 * bs_read_ue( &s ); + bs_read_ue( &s ); } /* vui */ @@ -600,27 +828,61 @@ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag ) w = bs_read( &s, 16 ); h = bs_read( &s, 16 ); } - p_dec->fmt_out.video.i_aspect = - VOUT_ASPECT_FACTOR * - w / h * - p_dec->fmt_out.video.i_width / p_dec->fmt_out.video.i_height; + if( h != 0 ) + p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * w / + h * p_dec->fmt_out.video.i_width / + p_dec->fmt_out.video.i_height; + else + p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR; } } free( dec ); + + if( p_sys->b_slice ) OUTPUT; + + /* We have a new SPS */ + if( p_sys->p_sps ) block_Release( p_sys->p_sps ); + p_sys->p_sps = p_frag; + + /* Do not append the SPS because we will insert it on keyframes */ + return p_pic; } else if( i_nal_type == NAL_PPS ) { bs_t s; + bs_init( &s, &p_frag->p_buffer[5], p_frag->i_buffer - 5 ); + bs_read_ue( &s ); // pps id + bs_read_ue( &s ); // sps id + bs_skip( &s, 1 ); // entropy coding mode flag + p_sys->i_pic_order_present_flag = bs_read( &s, 1 ); + + if( !p_sys->b_pps ) msg_Dbg( p_dec, "found NAL_PPS" ); + p_sys->b_pps = true; /* TODO */ + + if( p_sys->b_slice ) OUTPUT; + + /* We have a new PPS */ + if( p_sys->p_pps ) block_Release( p_sys->p_pps ); + p_sys->p_pps = p_frag; + + /* Do not append the PPS because we will insert it on keyframes */ + return p_pic; + } + else if( i_nal_type == NAL_AU_DELIMITER || + i_nal_type == NAL_SEI || + ( i_nal_type >= 13 && i_nal_type <= 18 ) ) + { + if( p_sys->b_slice ) OUTPUT; } +#undef OUTPUT /* Append the block */ block_ChainAppend( &p_sys->p_frame, p_frag ); return p_pic; } -