📄 parset.c
字号:
unsigned i;
unsigned n_ScalingList;
assert (rbsp != NULL);
if ((bitstream=calloc(1, sizeof(Bitstream)))==NULL) no_mem_exit("SeqParameterSet:bitstream");
// .. and use the rbsp provided (or allocated above) for the data
bitstream->streamBuffer = rbsp;
bitstream->bits_to_go = 8;
len+=u_v (8, "SPS: profile_idc", sps->profile_idc, bitstream);
len+=u_1 ("SPS: constrained_set0_flag", sps->constrained_set0_flag, bitstream);
len+=u_1 ("SPS: constrained_set1_flag", sps->constrained_set1_flag, bitstream);
len+=u_1 ("SPS: constrained_set2_flag", sps->constrained_set2_flag, bitstream);
len+=u_1 ("SPS: constrained_set3_flag", sps->constrained_set3_flag, bitstream);
len+=u_v (4, "SPS: reserved_zero_4bits", 0, bitstream);
len+=u_v (8, "SPS: level_idc", sps->level_idc, bitstream);
len+=ue_v ("SPS: seq_parameter_set_id", sps->seq_parameter_set_id, bitstream);
// Fidelity Range Extensions stuff
if( IS_FREXT_PROFILE(sps->profile_idc) )
{
len+=ue_v ("SPS: chroma_format_idc", sps->chroma_format_idc, bitstream);
if(img->yuv_format == YUV444)
len+=u_1 ("SPS: separate_colour_plane_flag", sps->separate_colour_plane_flag, bitstream);
len+=ue_v ("SPS: bit_depth_luma_minus8", sps->bit_depth_luma_minus8, bitstream);
len+=ue_v ("SPS: bit_depth_chroma_minus8", sps->bit_depth_chroma_minus8, bitstream);
len+=u_1 ("SPS: lossless_qpprime_y_zero_flag", img->lossless_qpprime_flag, bitstream);
//other chroma info to be added in the future
len+=u_1 ("SPS: seq_scaling_matrix_present_flag", sps->seq_scaling_matrix_present_flag, bitstream);
if(sps->seq_scaling_matrix_present_flag)
{
n_ScalingList = (sps->chroma_format_idc != YUV444) ? 8 : 12;
for(i=0; i<n_ScalingList; i++)
{
len+=u_1 ("SPS: seq_scaling_list_present_flag", sps->seq_scaling_list_present_flag[i], bitstream);
if(sps->seq_scaling_list_present_flag[i])
{
if(i<6)
len+=Scaling_List(ScalingList4x4input[i], ScalingList4x4[i], 16, &UseDefaultScalingMatrix4x4Flag[i], bitstream);
else
len+=Scaling_List(ScalingList8x8input[i-6], ScalingList8x8[i-6], 64, &UseDefaultScalingMatrix8x8Flag[i-6], bitstream);
}
}
}
}
len+=ue_v ("SPS: log2_max_frame_num_minus4", sps->log2_max_frame_num_minus4, bitstream);
len+=ue_v ("SPS: pic_order_cnt_type", sps->pic_order_cnt_type, bitstream);
if (sps->pic_order_cnt_type == 0)
len+=ue_v ("SPS: log2_max_pic_order_cnt_lsb_minus4", sps->log2_max_pic_order_cnt_lsb_minus4, bitstream);
else if (sps->pic_order_cnt_type == 1)
{
len+=u_1 ("SPS: delta_pic_order_always_zero_flag", sps->delta_pic_order_always_zero_flag, bitstream);
len+=se_v ("SPS: offset_for_non_ref_pic", sps->offset_for_non_ref_pic, bitstream);
len+=se_v ("SPS: offset_for_top_to_bottom_field", sps->offset_for_top_to_bottom_field, bitstream);
len+=ue_v ("SPS: num_ref_frames_in_pic_order_cnt_cycle", sps->num_ref_frames_in_pic_order_cnt_cycle, bitstream);
for (i=0; i<sps->num_ref_frames_in_pic_order_cnt_cycle; i++)
len+=se_v ("SPS: offset_for_ref_frame", sps->offset_for_ref_frame[i], bitstream);
}
len+=ue_v ("SPS: num_ref_frames", sps->num_ref_frames, bitstream);
len+=u_1 ("SPS: gaps_in_frame_num_value_allowed_flag", sps->gaps_in_frame_num_value_allowed_flag, bitstream);
len+=ue_v ("SPS: pic_width_in_mbs_minus1", sps->pic_width_in_mbs_minus1, bitstream);
len+=ue_v ("SPS: pic_height_in_map_units_minus1", sps->pic_height_in_map_units_minus1, bitstream);
len+=u_1 ("SPS: frame_mbs_only_flag", sps->frame_mbs_only_flag, bitstream);
if (!sps->frame_mbs_only_flag)
{
len+=u_1 ("SPS: mb_adaptive_frame_field_flag", sps->mb_adaptive_frame_field_flag, bitstream);
}
len+=u_1 ("SPS: direct_8x8_inference_flag", sps->direct_8x8_inference_flag, bitstream);
len+=u_1 ("SPS: frame_cropping_flag", sps->frame_cropping_flag, bitstream);
if (sps->frame_cropping_flag)
{
len+=ue_v ("SPS: frame_cropping_rect_left_offset", sps->frame_cropping_rect_left_offset, bitstream);
len+=ue_v ("SPS: frame_cropping_rect_right_offset", sps->frame_cropping_rect_right_offset, bitstream);
len+=ue_v ("SPS: frame_cropping_rect_top_offset", sps->frame_cropping_rect_top_offset, bitstream);
len+=ue_v ("SPS: frame_cropping_rect_bottom_offset", sps->frame_cropping_rect_bottom_offset, bitstream);
}
len+=u_1 ("SPS: vui_parameters_present_flag", sps->vui_parameters_present_flag, bitstream);
if (sps->vui_parameters_present_flag)
len+=GenerateVUI_parameters_rbsp(sps, bitstream); // currently a dummy, asserting
SODBtoRBSP(bitstream); // copies the last couple of bits into the byte buffer
LenInBytes=bitstream->byte_pos;
free (bitstream);
return LenInBytes;
}
/*!
***********************************************************************************************
* \brief
* int GeneratePic_parameter_set_rbsp (pic_parameter_set_rbsp_t *sps, char *rbsp);
*
* \param pps
* picture parameter structure
* \param rbsp
* buffer to be filled with the rbsp, size should be at least MAXIMUMPARSETRBSPSIZE
*
* \return
* size of the RBSP in bytes, negative in case of an error
*
* \note
* Picture Parameter VUI function is called, but the function implements
* an exit (-1)
************************************************************************************************
*/
int GeneratePic_parameter_set_rbsp (pic_parameter_set_rbsp_t *pps, byte *rbsp)
{
Bitstream *bitstream;
int len = 0, LenInBytes;
unsigned i;
unsigned n_ScalingList;
unsigned NumberBitsPerSliceGroupId;
int profile_idc;
assert (rbsp != NULL);
if ((bitstream=calloc(1, sizeof(Bitstream)))==NULL) no_mem_exit("PicParameterSet:bitstream");
// .. and use the rbsp provided (or allocated above) for the data
bitstream->streamBuffer = rbsp;
bitstream->bits_to_go = 8;
pps->pic_order_present_flag = img->pic_order_present_flag;
len+=ue_v ("PPS: pic_parameter_set_id", pps->pic_parameter_set_id, bitstream);
len+=ue_v ("PPS: seq_parameter_set_id", pps->seq_parameter_set_id, bitstream);
len+=u_1 ("PPS: entropy_coding_mode_flag", pps->entropy_coding_mode_flag, bitstream);
len+=u_1 ("PPS: pic_order_present_flag", pps->pic_order_present_flag, bitstream);
len+=ue_v ("PPS: num_slice_groups_minus1", pps->num_slice_groups_minus1, bitstream);
// FMO stuff
if(pps->num_slice_groups_minus1 > 0 )
{
len+=ue_v ("PPS: slice_group_map_type", pps->slice_group_map_type, bitstream);
if (pps->slice_group_map_type == 0)
for (i=0; i<=pps->num_slice_groups_minus1; i++)
len+=ue_v ("PPS: run_length_minus1[i]", pps->run_length_minus1[i], bitstream);
else if (pps->slice_group_map_type==2)
for (i=0; i<pps->num_slice_groups_minus1; i++)
{
len+=ue_v ("PPS: top_left[i]", pps->top_left[i], bitstream);
len+=ue_v ("PPS: bottom_right[i]", pps->bottom_right[i], bitstream);
}
else if (pps->slice_group_map_type == 3 ||
pps->slice_group_map_type == 4 ||
pps->slice_group_map_type == 5)
{
len+=u_1 ("PPS: slice_group_change_direction_flag", pps->slice_group_change_direction_flag, bitstream);
len+=ue_v ("PPS: slice_group_change_rate_minus1", pps->slice_group_change_rate_minus1, bitstream);
}
else if (pps->slice_group_map_type == 6)
{
if (pps->num_slice_groups_minus1>=4)
NumberBitsPerSliceGroupId=3;
else if (pps->num_slice_groups_minus1>=2)
NumberBitsPerSliceGroupId=2;
else if (pps->num_slice_groups_minus1>=1)
NumberBitsPerSliceGroupId=1;
else
NumberBitsPerSliceGroupId=0;
len+=ue_v ("PPS: pic_size_in_map_units_minus1", pps->pic_size_in_map_units_minus1, bitstream);
for(i=0; i<=pps->pic_size_in_map_units_minus1; i++)
len+= u_v (NumberBitsPerSliceGroupId, "PPS: >slice_group_id[i]", pps->slice_group_id[i], bitstream);
}
}
// End of FMO stuff
len+=ue_v ("PPS: num_ref_idx_l0_active_minus1", pps->num_ref_idx_l0_active_minus1, bitstream);
len+=ue_v ("PPS: num_ref_idx_l1_active_minus1", pps->num_ref_idx_l1_active_minus1, bitstream);
len+=u_1 ("PPS: weighted_pred_flag", pps->weighted_pred_flag, bitstream);
len+=u_v (2, "PPS: weighted_bipred_idc", pps->weighted_bipred_idc, bitstream);
len+=se_v ("PPS: pic_init_qp_minus26", pps->pic_init_qp_minus26, bitstream);
len+=se_v ("PPS: pic_init_qs_minus26", pps->pic_init_qs_minus26, bitstream);
profile_idc = IdentifyProfile();
if( IS_FREXT_PROFILE(profile_idc) )
len+=se_v ("PPS: chroma_qp_index_offset", pps->cb_qp_index_offset, bitstream);
else
len+=se_v ("PPS: chroma_qp_index_offset", pps->chroma_qp_index_offset, bitstream);
len+=u_1 ("PPS: deblocking_filter_control_present_flag", pps->deblocking_filter_control_present_flag, bitstream);
len+=u_1 ("PPS: constrained_intra_pred_flag", pps->constrained_intra_pred_flag, bitstream);
len+=u_1 ("PPS: redundant_pic_cnt_present_flag", pps->redundant_pic_cnt_present_flag, bitstream);
// Fidelity Range Extensions stuff
if( IS_FREXT_PROFILE(profile_idc) )
{
len+=u_1 ("PPS: transform_8x8_mode_flag", pps->transform_8x8_mode_flag, bitstream);
len+=u_1 ("PPS: pic_scaling_matrix_present_flag", pps->pic_scaling_matrix_present_flag, bitstream);
if(pps->pic_scaling_matrix_present_flag)
{
n_ScalingList = 6 + ((active_sps->chroma_format_idc != 3) ? 2 : 6) * pps->transform_8x8_mode_flag;
for(i=0; i<n_ScalingList; i++) // SS-70226
{
len+=u_1 ("PPS: pic_scaling_list_present_flag", pps->pic_scaling_list_present_flag[i], bitstream);
if(pps->pic_scaling_list_present_flag[i])
{
if(i<6)
len+=Scaling_List(ScalingList4x4input[i], ScalingList4x4[i], 16, &UseDefaultScalingMatrix4x4Flag[i], bitstream);
else
len+=Scaling_List(ScalingList8x8input[i-6], ScalingList8x8[i-6], 64, &UseDefaultScalingMatrix8x8Flag[i-6], bitstream);
}
}
}
len+=se_v ("PPS: second_chroma_qp_index_offset", pps->cr_qp_index_offset, bitstream);
}
SODBtoRBSP(bitstream); // copies the last couple of bits into the byte buffer
LenInBytes=bitstream->byte_pos;
// Get rid of the helper structures
free (bitstream);
return LenInBytes;
}
/*!
*************************************************************************************
* \brief
* Returns the Profile
*
* \return
* Profile according to Annex A
*
* \note
* Function is currently a dummy. Should "calculate" the profile from those
* config file parameters. E.g.
*
* Profile = Baseline;
* if (CABAC Used || Interlace used) Profile=Main;
* if (!Cabac Used) && (Bframes | SPframes) Profile = Streaming;
*
*************************************************************************************
*/
int IdentifyProfile(void)
{
return params->ProfileIDC;
}
/*!
*************************************************************************************
* \brief
* Returns the Level
*
* \return
* Level according to Annex A
*
* \note
* This function is currently a dummy, but should calculate the level out of
* the config file parameters (primarily the picture size)
*************************************************************************************
*/
int IdentifyLevel(void)
{
return params->LevelIDC;
}
/*!
*************************************************************************************
* \brief
* Function body for VUI Parameter generation (to be done)
*
* \return
* exits with error message
*************************************************************************************
*/
static int GenerateVUI_parameters_rbsp(seq_parameter_set_rbsp_t *sps, Bitstream *bitstream)
{
int len=0;
vui_seq_parameters_t *vui_seq_parameters = &(sps->vui_seq_parameters);
len+=u_1 ("VUI: aspect_ratio_info_present_flag", vui_seq_parameters->aspect_ratio_info_present_flag, bitstream);
if (vui_seq_parameters->aspect_ratio_info_present_flag)
{
len+=u_v (8,"VUI: aspect_ratio_idc", vui_seq_parameters->aspect_ratio_idc, bitstream);
if (vui_seq_parameters->aspect_ratio_idc == 255)
{
len+=u_v (16,"VUI: sar_width", vui_seq_parameters->sar_width, bitstream);
len+=u_v (16,"VUI: sar_height", vui_seq_parameters->sar_height, bitstream);
}
}
len+=u_1 ("VUI: overscan_info_present_flag", vui_seq_parameters->overscan_info_present_flag, bitstream);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -