static block_t *PacketizeParse(void *p_private, bool *pb_ts_used, block_t *p_block)
{
decoder_t *p_dec = p_private;
decoder_sys_t *p_sys = p_dec->p_sys;
/* Remove trailing 0 bytes */
while (p_block->i_buffer > 5 && p_block->p_buffer[p_block->i_buffer-1] == 0x00 )
p_block->i_buffer--;
p_block = ParseNALBlock( p_dec, pb_ts_used, p_block );
if( p_block )
cc_storage_commit( p_sys->p_ccs, p_block );
return p_block;
}
static block_t *OutputPicture( decoder_t *p_dec )
{
decoder_sys_t *p_sys = p_dec->p_sys;
block_t *p_pic;
if ( !p_sys->b_header && p_sys->i_recovery_frames != -1 )
{
if( p_sys->i_recovery_frames == 0 )
{
msg_Dbg( p_dec, "Recovery from SEI recovery point complete" );
p_sys->b_header = true;
}
--p_sys->i_recovery_frames;
}
if( !p_sys->b_header && p_sys->i_recovery_frames == -1 &&
p_sys->slice.i_frame_type != BLOCK_FLAG_TYPE_I)
return NULL;
const bool b_sps_pps_i = p_sys->slice.i_frame_type == BLOCK_FLAG_TYPE_I &&
p_sys->b_sps &&
p_sys->b_pps;
if( b_sps_pps_i || p_sys->b_frame_sps || p_sys->b_frame_pps )
{
block_t *p_head = NULL;
if( p_sys->p_frame->i_flags & BLOCK_FLAG_PRIVATE_AUD )
{
p_head = p_sys->p_frame;
p_sys->p_frame = p_sys->p_frame->p_next;
if( p_sys->p_frame == NULL )
p_sys->pp_frame_last = &p_sys->p_frame;
p_head->p_next = NULL;
}
block_t *p_list = NULL;
block_t **pp_list_tail = &p_list;
for( int i = 0; i <= H264_SPS_ID_MAX && (b_sps_pps_i || p_sys->b_frame_sps); i++ )
{
if( p_sys->pp_sps[i] )
block_ChainLastAppend( &pp_list_tail, block_Duplicate( p_sys->pp_sps[i] ) );
}
for( int i = 0; i < H264_PPS_ID_MAX && (b_sps_pps_i || p_sys->b_frame_pps); i++ )
{
if( p_sys->pp_pps[i] )
block_ChainLastAppend( &pp_list_tail, block_Duplicate( p_sys->pp_pps[i] ) );
}
if( b_sps_pps_i && p_list )
p_sys->b_header = true;
if( p_list )
block_ChainAppend( &p_head, p_list );
if( p_sys->p_frame )
block_ChainAppend( &p_head, p_sys->p_frame );
p_pic = block_ChainGather( p_head );
}
else
{
p_pic = block_ChainGather( p_sys->p_frame );
}
unsigned i_num_clock_ts = 2;
if( p_sys->b_frame_mbs_only == 0 )
{
if( p_sys->b_pic_struct_present_flag && p_sys->i_pic_struct < 9 )
{
const uint8_t rgi_numclock[9] = { 1, 1, 1, 2, 2, 3, 3, 2, 3 };
i_num_clock_ts = rgi_numclock[ p_sys->i_pic_struct ];
}
else if( p_sys->slice.i_field_pic_flag ) /* See D-1 and E-6 */
{
i_num_clock_ts = 1;
}
}
if( p_sys->i_time_scale && p_pic->i_length == 0 )
{
p_pic->i_length = CLOCK_FREQ * i_num_clock_ts *
p_sys->i_num_units_in_tick / p_sys->i_time_scale;
}
mtime_t i_field_pts_diff = -1;
if( p_sys->b_frame_mbs_only == 0 && p_sys->b_pic_struct_present_flag )
{
switch( p_sys->i_pic_struct )
{
/* Top and Bottom field slices */
case 1:
case 2:
if( !p_sys->b_even_frame )
{
p_pic->i_flags |= (p_sys->i_pic_struct == 1) ? BLOCK_FLAG_TOP_FIELD_FIRST
: BLOCK_FLAG_BOTTOM_FIELD_FIRST;
}
else if( p_pic->i_pts <= VLC_TS_INVALID && p_sys->i_prev_pts > VLC_TS_INVALID && p_pic->i_length )
{
/* interpolate from even frame */
i_field_pts_diff = p_pic->i_length;
}
p_sys->b_even_frame = !p_sys->b_even_frame;
break;
/* Each of the following slices contains multiple fields */
case 3:
p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
p_sys->b_even_frame = false;
break;
case 4:
p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
p_sys->b_even_frame = false;
break;
case 5:
p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
break;
case 6:
p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
break;
default:
p_sys->b_even_frame = false;
break;
}
}
/* set dts/pts to current block timestamps */
p_pic->i_dts = p_sys->i_frame_dts;
p_pic->i_pts = p_sys->i_frame_pts;
/* Fixup missing timestamps after split (multiple AU/block)*/
if( p_pic->i_dts <= VLC_TS_INVALID )
p_pic->i_dts = p_sys->i_prev_dts;
/* PTS Fixup, interlaced fields (multiple AU/block) */
if( p_pic->i_pts <= VLC_TS_INVALID && p_sys->i_time_scale )
{
mtime_t i_pts_delay = CLOCK_FREQ * p_sys->i_dpb_output_delay *
p_sys->i_num_units_in_tick / p_sys->i_time_scale;
p_pic->i_pts = p_pic->i_dts + i_pts_delay;
if( i_field_pts_diff >= 0 )
p_pic->i_pts += i_field_pts_diff;
}
/* save for next pic fixups */
p_sys->i_prev_dts = p_pic->i_dts;
p_sys->i_prev_pts = p_pic->i_pts;
p_pic->i_flags |= p_sys->slice.i_frame_type;
p_pic->i_flags &= ~BLOCK_FLAG_PRIVATE_AUD;
if( !p_sys->b_header )
p_pic->i_flags |= BLOCK_FLAG_PREROLL;
/* reset after output */
p_sys->i_frame_dts = VLC_TS_INVALID;
p_sys->i_frame_pts = VLC_TS_INVALID;
p_sys->i_dpb_output_delay = 0;
p_sys->slice.i_frame_type = 0;
p_sys->p_frame = NULL;
p_sys->pp_frame_last = &p_sys->p_frame;
p_sys->b_frame_sps = false;
p_sys->b_frame_pps = false;
p_sys->b_slice = false;
/* CC */
cc_storage_commit( p_sys->p_ccs, p_pic );
return p_pic;
}
static block_t *OutputPicture( decoder_t *p_dec )
{
decoder_sys_t *p_sys = p_dec->p_sys;
block_t *p_pic = NULL;
block_t **pp_pic_last = &p_pic;
if( unlikely(!p_sys->p_frame) )
{
assert( p_sys->p_frame );
return NULL;
}
/* Bind matched/referred PPS and SPS */
const h264_picture_parameter_set_t *p_pps = p_sys->p_active_pps;
const h264_sequence_parameter_set_t *p_sps = p_sys->p_active_sps;
if( !p_pps || !p_sps )
{
DropStoredNAL( p_sys );
return NULL;
}
if( !p_sys->b_recovered && p_sys->i_recoveryfnum == UINT_MAX &&
p_sys->i_recovery_frame_cnt == UINT_MAX && p_sys->slice.type == H264_SLICE_TYPE_I )
{
/* No way to recover using SEI, just sync on I Slice */
p_sys->b_recovered = true;
}
bool b_need_sps_pps = p_sys->slice.type == H264_SLICE_TYPE_I &&
p_sys->p_active_pps && p_sys->p_active_sps;
/* Handle SEI recovery */
if ( !p_sys->b_recovered && p_sys->i_recovery_frame_cnt != UINT_MAX &&
p_sys->i_recoveryfnum == UINT_MAX )
{
p_sys->i_recoveryfnum = p_sys->slice.i_frame_num + p_sys->i_recovery_frame_cnt;
b_need_sps_pps = true; /* SPS/PPS must be inserted for SEI recovery */
msg_Dbg( p_dec, "Recovering using SEI, prerolling %u reference pics", p_sys->i_recovery_frame_cnt );
}
if( p_sys->i_recoveryfnum != UINT_MAX )
{
assert(p_sys->b_recovered == false);
const unsigned maxFrameNum = 1 << (p_sps->i_log2_max_frame_num + 4);
if( (p_sys->i_recoveryfnum > maxFrameNum &&
(unsigned)p_sys->slice.i_frame_num <= maxFrameNum / 2 &&
(unsigned)p_sys->slice.i_frame_num >= p_sys->i_recoveryfnum % maxFrameNum ) ||
(unsigned)p_sys->slice.i_frame_num >= p_sys->i_recoveryfnum )
{
p_sys->i_recoveryfnum = UINT_MAX;
p_sys->b_recovered = true;
msg_Dbg( p_dec, "Recovery from SEI recovery point complete" );
}
}
/* Gather PPS/SPS if required */
block_t *p_xpsnal = NULL;
block_t **pp_xpsnal_tail = &p_xpsnal;
if( b_need_sps_pps || p_sys->b_new_sps || p_sys->b_new_pps )
{
for( int i = 0; i <= H264_SPS_ID_MAX && (b_need_sps_pps || p_sys->b_new_sps); i++ )
{
if( p_sys->sps[i].p_block )
block_ChainLastAppend( &pp_xpsnal_tail, block_Duplicate( p_sys->sps[i].p_block ) );
}
for( int i = 0; i < H264_PPS_ID_MAX && (b_need_sps_pps || p_sys->b_new_pps); i++ )
{
if( p_sys->pps[i].p_block )
block_ChainLastAppend( &pp_xpsnal_tail, block_Duplicate( p_sys->pps[i].p_block ) );
}
}
/* Now rebuild NAL Sequence, inserting PPS/SPS if any */
if( p_sys->p_frame->i_flags & BLOCK_FLAG_PRIVATE_AUD )
{
block_t *p_au = p_sys->p_frame;
p_sys->p_frame = p_au->p_next;
p_au->p_next = NULL;
p_au->i_flags &= ~BLOCK_FLAG_PRIVATE_AUD;
block_ChainLastAppend( &pp_pic_last, p_au );
}
if( p_xpsnal )
block_ChainLastAppend( &pp_pic_last, p_xpsnal );
if( p_sys->p_sei )
block_ChainLastAppend( &pp_pic_last, p_sys->p_sei );
assert( p_sys->p_frame );
if( p_sys->p_frame )
block_ChainLastAppend( &pp_pic_last, p_sys->p_frame );
/* Reset chains, now empty */
p_sys->p_frame = NULL;
p_sys->pp_frame_last = &p_sys->p_frame;
p_sys->p_sei = NULL;
p_sys->pp_sei_last = &p_sys->p_sei;
p_pic = block_ChainGather( p_pic );
if( !p_pic )
return NULL;
/* for PTS Fixup, interlaced fields (multiple AU/block) */
int tFOC = 0, bFOC = 0, PictureOrderCount = 0;
h264_compute_poc( p_sps, &p_sys->slice, &p_sys->pocctx, &PictureOrderCount, &tFOC, &bFOC );
unsigned i_num_clock_ts = h264_get_num_ts( p_sps, &p_sys->slice, p_sys->i_pic_struct, tFOC, bFOC );
if( p_sps->frame_mbs_only_flag == 0 && p_sps->vui.b_pic_struct_present_flag )
{
switch( p_sys->i_pic_struct )
{
/* Top and Bottom field slices */
case 1:
case 2:
p_pic->i_flags |= BLOCK_FLAG_SINGLE_FIELD;
p_pic->i_flags |= (!p_sys->slice.i_bottom_field_flag) ? BLOCK_FLAG_TOP_FIELD_FIRST
: BLOCK_FLAG_BOTTOM_FIELD_FIRST;
break;
/* Each of the following slices contains multiple fields */
case 3:
p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
break;
case 4:
p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
break;
case 5:
p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
break;
case 6:
p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
break;
default:
break;
}
}
/* set dts/pts to current block timestamps */
p_pic->i_dts = p_sys->i_frame_dts;
p_pic->i_pts = p_sys->i_frame_pts;
/* Fixup missing timestamps after split (multiple AU/block)*/
if( p_pic->i_dts <= VLC_TS_INVALID )
p_pic->i_dts = date_Get( &p_sys->dts );
if( p_sys->slice.type == H264_SLICE_TYPE_I )
p_sys->prevdatedpoc.pts = VLC_TS_INVALID;
if( p_pic->i_pts == VLC_TS_INVALID )
{
if( p_sys->prevdatedpoc.pts > VLC_TS_INVALID &&
date_Get( &p_sys->dts ) != VLC_TS_INVALID )
{
date_t pts = p_sys->dts;
date_Set( &pts, p_sys->prevdatedpoc.pts );
int diff = tFOC - p_sys->prevdatedpoc.num;
if( diff > 0 )
date_Increment( &pts, diff );
else
date_Decrement( &pts, -diff );
p_pic->i_pts = date_Get( &pts );
}
/* In case there's no PTS at all */
else if( p_sys->slice.i_nal_ref_idc == 0 &&
p_sys->slice.type == H264_SLICE_TYPE_B )
{
p_pic->i_pts = p_pic->i_dts;
}
else if( p_sys->slice.type == H264_SLICE_TYPE_I &&
date_Get( &p_sys->dts ) != VLC_TS_INVALID )
{
/* Hell no PTS on IDR. We're totally blind */
date_t pts = p_sys->dts;
date_Increment( &pts, 2 );
p_pic->i_pts = date_Get( &pts );
}
}
if( p_pic->i_pts > VLC_TS_INVALID )
{
p_sys->prevdatedpoc.pts = p_pic->i_pts;
p_sys->prevdatedpoc.num = PictureOrderCount;
}
if( p_pic->i_length == 0 )
{
if( p_sps->vui.i_time_scale )
{
p_pic->i_length = CLOCK_FREQ * i_num_clock_ts *
p_sps->vui.i_num_units_in_tick / p_sps->vui.i_time_scale;
}
else
{
date_t next = p_sys->dts;
date_Increment( &next, i_num_clock_ts );
p_pic->i_length = date_Get( &next ) - date_Get( &p_sys->dts );
}
}
#if 0
msg_Err(p_dec, "F/BOC %d/%d POC %d %d rec %d flags %x ref%d fn %d fp %d %d pts %ld len %ld",
tFOC, bFOC, PictureOrderCount,
p_sys->slice.type, p_sys->b_recovered, p_pic->i_flags,
p_sys->slice.i_nal_ref_idc, p_sys->slice.i_frame_num, p_sys->slice.i_field_pic_flag,
p_pic->i_pts - p_pic->i_dts, p_pic->i_pts % (100*CLOCK_FREQ), p_pic->i_length);
#endif
/* save for next pic fixups */
if( date_Get( &p_sys->dts ) != VLC_TS_INVALID )
{
if( p_sys->i_next_block_flags & BLOCK_FLAG_DISCONTINUITY )
date_Set( &p_sys->dts, VLC_TS_INVALID );
else
date_Increment( &p_sys->dts, i_num_clock_ts );
}
if( p_pic )
{
p_pic->i_flags |= p_sys->i_next_block_flags;
p_sys->i_next_block_flags = 0;
}
switch( p_sys->slice.type )
{
case H264_SLICE_TYPE_P:
p_pic->i_flags |= BLOCK_FLAG_TYPE_P;
break;
case H264_SLICE_TYPE_B:
p_pic->i_flags |= BLOCK_FLAG_TYPE_B;
break;
case H264_SLICE_TYPE_I:
p_pic->i_flags |= BLOCK_FLAG_TYPE_I;
default:
break;
}
if( !p_sys->b_recovered )
{
if( p_sys->i_recoveryfnum != UINT_MAX ) /* recovering from SEI */
p_pic->i_flags |= BLOCK_FLAG_PREROLL;
else
p_pic->i_flags |= BLOCK_FLAG_DROP;
}
p_pic->i_flags &= ~BLOCK_FLAG_PRIVATE_AUD;
/* reset after output */
p_sys->i_frame_dts = VLC_TS_INVALID;
p_sys->i_frame_pts = VLC_TS_INVALID;
p_sys->i_dpb_output_delay = 0;
p_sys->i_pic_struct = UINT8_MAX;
p_sys->i_recovery_frame_cnt = UINT_MAX;
p_sys->slice.type = H264_SLICE_TYPE_UNKNOWN;
p_sys->p_sei = NULL;
p_sys->pp_sei_last = &p_sys->p_sei;
p_sys->b_new_sps = false;
p_sys->b_new_pps = false;
p_sys->b_slice = false;
/* CC */
cc_storage_commit( p_sys->p_ccs, p_pic );
return p_pic;
}
