www.pudn.com > p264decoder.zip > set.c
/*****************************************************************************
* p264: h264 decoder
*****************************************************************************
* Copyright (C) 2003 Laurent Aimar
* $Id: set.c,v 1.1 2004/06/03 19:27:07 fenrir Exp $
*
* Authors: Laurent Aimar
*
* Maintained by Peter Lee (lspbeyond@126.com)
* 2005-2006 at icas of Ningbo university, China
* p264 Decoder site: http://p264decoder.zj.com
*
* 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
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* 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.
*****************************************************************************/
#include
#include
#include
#include
#include "core/core.h"
#include "set.h"
/* return -1 if invalid, else the id */
int p264_sps_read( bs_t *s, p264_sps_t sps_array[32] )
{
p264_sps_t *sps;
int i_profile_idc;
int i_level_idc;
int b_constraint_set0;
int b_constraint_set1;
int b_constraint_set2;
int id;
i_profile_idc = bs_read( s, 8 );
b_constraint_set0 = bs_read( s, 1 );
b_constraint_set1 = bs_read( s, 1 );
b_constraint_set2 = bs_read( s, 1 );
bs_skip( s, 5 ); /* reserved */
i_level_idc = bs_read( s, 8 );
id = bs_read_ue( s );
if( bs_eof( s ) || id >= 32 )
{
/* the sps is invalid, no need to corrupt sps_array[0] */
return -1;
}
sps = &sps_array[id];
sps->i_id = id;
/* put pack parsed value */
sps->i_profile_idc = i_profile_idc;
sps->i_level_idc = i_level_idc;
sps->b_constraint_set0 = b_constraint_set0;
sps->b_constraint_set1 = b_constraint_set1;
sps->b_constraint_set2 = b_constraint_set2;
sps->i_log2_max_frame_num = bs_read_ue( s ) + 4;
sps->i_poc_type = bs_read_ue( s );
if( sps->i_poc_type == 0 )
{
sps->i_log2_max_poc_lsb = bs_read_ue( s ) + 4;
}
else if( sps->i_poc_type == 1 )
{
int i;
sps->b_delta_pic_order_always_zero = bs_read( s, 1 );
sps->i_offset_for_non_ref_pic = bs_read_se( s );
sps->i_offset_for_top_to_bottom_field = bs_read_se( s );
sps->i_num_ref_frames_in_poc_cycle = bs_read_ue( s );
if( sps->i_num_ref_frames_in_poc_cycle > 256 )
{
/* FIXME what to do */
sps->i_num_ref_frames_in_poc_cycle = 256;
}
for( i = 0; i < sps->i_num_ref_frames_in_poc_cycle; i++ )
{
sps->i_offset_for_ref_frame[i] = bs_read_se( s );
}
}
else if( sps->i_poc_type > 2 )
{
goto error;
}
sps->i_num_ref_frames = bs_read_ue( s );
sps->b_gaps_in_frame_num_value_allowed = bs_read( s, 1 );
sps->i_mb_width = bs_read_ue( s ) + 1;
sps->i_mb_height= bs_read_ue( s ) + 1;
sps->b_frame_mbs_only = bs_read( s, 1 );
if( !sps->b_frame_mbs_only )
{
sps->b_mb_adaptive_frame_field = bs_read( s, 1 );
}
else
{
sps->b_mb_adaptive_frame_field = 0;
}
sps->b_direct8x8_inference = bs_read( s, 1 );
sps->b_crop = bs_read( s, 1 );
if( sps->b_crop )
{
sps->crop.i_left = bs_read_ue( s );
sps->crop.i_right = bs_read_ue( s );
sps->crop.i_top = bs_read_ue( s );
sps->crop.i_bottom= bs_read_ue( s );
}
else
{
sps->crop.i_left = 0;
sps->crop.i_right = 0;
sps->crop.i_top = 0;
sps->crop.i_bottom= 0;
}
sps->b_vui = bs_read( s, 1 );
if( sps->b_vui )
{
/* FIXME */
}
else
{
}
if( bs_eof( s ) )
{
/* no rbsp trailing */
fprintf( stderr, "incomplete SPS\n" );
goto error;
}
fprintf( stderr, "p264_sps_read: sps:0x%x profile:%d/%d poc:%d ref:%d %xx%d crop:%d-%d-%d-%d\n",
sps->i_id,
sps->i_profile_idc, sps->i_level_idc,
sps->i_poc_type,
sps->i_num_ref_frames,
sps->i_mb_width, sps->i_mb_height,
sps->crop.i_left, sps->crop.i_right,
sps->crop.i_top, sps->crop.i_bottom );
return id;
error:
/* invalidate this sps */
sps->i_id = -1;
return -1;
}
/* return -1 if invalid, else the id */
int p264_pps_read( bs_t *s, p264_pps_t pps_array[256] )
{
p264_pps_t *pps;
int id;
int i;
id = bs_read_ue( s ); //pps id
if( bs_eof( s ) || id >= 256 )
{
fprintf( stderr, "id invalid\n" );
return -1;
}
pps = &pps_array[id];
pps->i_id = id;
pps->i_sps_id = bs_read_ue( s );
if( pps->i_sps_id >= 32 )
{
goto error;
}
pps->b_cabac = bs_read( s, 1 );
pps->b_pic_order = bs_read( s, 1 );
pps->i_num_slice_groups = bs_read_ue( s ) + 1;
if( pps->i_num_slice_groups > 1 )
{
fprintf( stderr, "FMO unsupported\n " );
pps->i_slice_group_map_type =bs_read_ue( s );
if( pps->i_slice_group_map_type == 0 )
{
for( i = 0; i < pps->i_num_slice_groups; i++ )
{
pps->i_run_length[i] = bs_read_ue( s );
}
}
else if( pps->i_slice_group_map_type == 2 )
{
for( i = 0; i < pps->i_num_slice_groups; i++ )
{
pps->i_top_left[i] = bs_read_ue( s );
pps->i_bottom_right[i] = bs_read_ue( s );
}
}
else if( pps->i_slice_group_map_type == 3 ||
pps->i_slice_group_map_type == 4 ||
pps->i_slice_group_map_type == 5 )
{
pps->b_slice_group_change_direction = bs_read( s, 1 );
pps->i_slice_group_change_rate = bs_read_ue( s ) + 1;
}
else if( pps->i_slice_group_map_type == 6 )
{
pps->i_pic_size_in_map_units = bs_read_ue( s ) + 1;
for( i = 0; i < pps->i_pic_size_in_map_units; i++ )
{
/* FIXME */
/* pps->i_slice_group_id = bs_read( s, ceil( log2( pps->i_pic_size_in_map_units +1 ) ) ); */
}
}
}
pps->i_num_ref_idx_l0_active = bs_read_ue( s ) + 1;
pps->i_num_ref_idx_l1_active = bs_read_ue( s ) + 1;
pps->b_weighted_pred = bs_read( s, 1 );
pps->b_weighted_bipred = bs_read( s, 2 );
pps->i_pic_init_qp = bs_read_se( s ) + 26;
pps->i_pic_init_qs = bs_read_se( s ) + 26;
pps->i_chroma_qp_index_offset = bs_read_se( s );
pps->b_deblocking_filter_control = bs_read( s, 1 );
pps->b_constrained_intra_pred = bs_read( s, 1 );
pps->b_redundant_pic_cnt = bs_read( s, 1 );
if( bs_eof( s ) )
{
/* no rbsp trailing */
fprintf( stderr, "incomplete PPS\n" );
goto error;
}
fprintf( stderr, "p264_sps_read: pps:0x%x sps:0x%x %s slice_groups=%d ref0:%d ref1:%d QP:%d QS:%d QC=%d DFC:%d CIP:%d RPC:%d\n",
pps->i_id, pps->i_sps_id,
pps->b_cabac ? "CABAC" : "CAVLC",
pps->i_num_slice_groups,
pps->i_num_ref_idx_l0_active,
pps->i_num_ref_idx_l1_active,
pps->i_pic_init_qp, pps->i_pic_init_qs, pps->i_chroma_qp_index_offset,
pps->b_deblocking_filter_control,
pps->b_constrained_intra_pred,
pps->b_redundant_pic_cnt );
//lsp?? //temp way
for( i = 0; i < 6; i++ )
pps->scaling_list[i] = p264_cqm_flat16;
//lsp
return id;
error:
pps->i_id = -1;
return -1;
}