📄 h.264
字号:
pps->weighted_bipred_idc = input->WeightedBiprediction;
pps->pic_init_qp_minus26 = 0; // hard coded to zero, QP lives in the slice header
pps->pic_init_qs_minus26 = 0;
pps->chroma_qp_index_offset = 0; // double check: is this chroma fidelity thing already implemented???
pps->deblocking_filter_control_present_flag = input->LFSendParameters;
pps->constrained_intra_pred_flag = input->UseConstrainedIntraPred;
pps->redundant_pic_cnt_present_flag = 0;
// the picture vui consists currently of the cropping rectangle, which cannot
// used by the current decoder and hence is never sent.
#ifdef G50_SPS
sps->frame_cropping_flag = FALSE;
#else
pps->frame_cropping_flag = FALSE;
#endif
};
/*!
*************************************************************************************
* \brief
* int GenerateSeq_parameter_set_rbsp (seq_parameter_set_rbsp_t *sps, char *rbsp);
*
* \param
* sps: sequence parameter structure
* rbsp: buffer to be filled with the rbsp, size should be at least MAXIMUMPARSETRBSPSIZE
*
* \return
* size of the RBSP in bytes
*
* \note
* Sequence Parameter VUI function is called, but the function implements
* an exit (-1)
*************************************************************************************
*/
int GenerateSeq_parameter_set_rbsp (seq_parameter_set_rbsp_t *sps, char *rbsp)
{
DataPartition *partition;
int len = 0, LenInBytes;
unsigned i;
assert (rbsp != NULL);
// In order to use the entropy coding functions from golomb.c we need
// to allocate a partition structure. It will be freed later in this
// function
if ((partition=calloc(1,sizeof(DataPartition)))==NULL) no_mem_exit("SeqParameterSet:partition");
if ((partition->bitstream=calloc(1, sizeof(Bitstream)))==NULL) no_mem_exit("SeqParameterSet:bitstream");
// .. and use the rbsp provided (or allocated above) for the data
partition->bitstream->streamBuffer = rbsp;
partition->bitstream->bits_to_go = 8;
len+=u_v (8, "SPS: profile_idc", sps->profile_idc, partition);
#ifdef G50_SPS
len+=u_1 ("SPS: constrained_set0_flag", sps->constrained_set0_flag, partition);
len+=u_1 ("SPS: constrained_set1_flag", sps->constrained_set1_flag, partition);
len+=u_1 ("SPS: constrained_set2_flag", sps->constrained_set2_flag, partition);
len+=u_v (5, "SPS: reserved_zero", 0, partition);
#endif
len+=u_v (8, "SPS: level_idc", sps->level_idc, partition);
#ifndef G50_SPS
len+=u_1 ("SPS: more_than_one_slice_group_allowed_flag", sps->more_than_one_slice_group_allowed_flag, partition);
len+=u_1 ("SPS: arbitrary_slice_order_allowed_flag", sps->arbitrary_slice_order_allowed_flag, partition);
len+=u_1 ("SPS: redundant_slices_allowed_flag", sps->redundant_slices_allowed_flag, partition);
#endif
len+=ue_v ("SPS: seq_parameter_set_id", sps->seq_parameter_set_id, partition);
len+=ue_v ("SPS: log2_max_frame_num_minus4", sps->log2_max_frame_num_minus4, partition);
len+=ue_v ("SPS: pic_order_cnt_type", sps->pic_order_cnt_type, partition);
// POC200301
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, partition);
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, partition);
len+=se_v ("SPS: offset_for_non_ref_pic", sps->offset_for_non_ref_pic, partition);
len+=se_v ("SPS: offset_for_top_to_bottom_field", sps->offset_for_top_to_bottom_field, partition);
len+=ue_v ("SPS: num_ref_frames_in_pic_order_cnt_cycle", sps->num_ref_frames_in_pic_order_cnt_cycle, partition);
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], partition);
}
len+=ue_v ("SPS: num_ref_frames", sps->num_ref_frames, partition);
len+=u_1 ("SPS: gaps_in_frame_num_value_allowed_flag", sps->gaps_in_frame_num_value_allowed_flag, partition);
len+=ue_v ("SPS: pic_width_in_mbs_minus1", sps->pic_width_in_mbs_minus1, partition);
len+=ue_v ("SPS: pic_height_in_map_units_minus1", sps->pic_height_in_map_units_minus1, partition);
len+=u_1 ("SPS: frame_mbs_only_flag", sps->frame_mbs_only_flag, partition);
if (!sps->frame_mbs_only_flag)
{
len+=u_1 ("SPS: mb_adaptive_frame_field_flag", sps->mb_adaptive_frame_field_flag, partition);
}
len+=u_1 ("SPS: direct_8x8_inference_flag", sps->direct_8x8_inference_flag, partition);
#ifdef G50_SPS
len+=u_1 ("SPS: frame_cropping_flag", sps->frame_cropping_flag, partition);
if (sps->frame_cropping_flag)
{
len+=ue_v ("SPS: frame_cropping_rect_left_offset", sps->frame_cropping_rect_left_offset, partition);
len+=ue_v ("SPS: frame_cropping_rect_right_offset", sps->frame_cropping_rect_right_offset, partition);
len+=ue_v ("SPS: frame_cropping_rect_top_offset", sps->frame_cropping_rect_top_offset, partition);
len+=ue_v ("SPS: frame_cropping_rect_bottom_offset", sps->frame_cropping_rect_bottom_offset, partition);
}
#endif
len+=u_1 ("SPS: vui_parameters_present_flag", sps->vui_parameters_present_flag, partition);
if (sps->vui_parameters_present_flag)
len+=GenerateVUISequenceParameters(); // currently a dummy, asserting
SODBtoRBSP(partition->bitstream); // copies the last couple of bits into the byte buffer
LenInBytes=partition->bitstream->byte_pos;
free (partition->bitstream);
free (partition);
return LenInBytes;
}
/*!
*************************************************************************************
* \brief
* int GeneratePic_parameter_set_rbsp (pic_parameter_set_rbsp_t *sps, char *rbsp);
*
* \param
* pps: sequence parameter structure
* 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, char *rbsp)
{
DataPartition *partition;
int len = 0, LenInBytes;
unsigned i;
unsigned NumberBitsPerSliceGroupId;
assert (rbsp != NULL);
// In order to use the entropy coding functions from golomb.c we need
// to allocate a partition structure. It will be freed later in this
// function
if ((partition=calloc(1,sizeof(DataPartition)))==NULL) no_mem_exit("PicParameterSet:partition");
if ((partition->bitstream=calloc(1, sizeof(Bitstream)))==NULL) no_mem_exit("PicParameterSet:bitstream");
// .. and use the rbsp provided (or allocated above) for the data
partition->bitstream->streamBuffer = rbsp;
partition->bitstream->bits_to_go = 8;
len+=ue_v ("PPS: pic_parameter_set_id", pps->pic_parameter_set_id, partition);
len+=ue_v ("PPS: seq_parameter_set_id", pps->seq_parameter_set_id, partition);
len+=u_1 ("PPS: entropy_coding_mode_flag", pps->entropy_coding_mode_flag, partition);
len+=u_1 ("PPS: pic_order_present_flag", pps->pic_order_present_flag, partition);
len+=ue_v ("PPS: num_slice_groups_minus1", pps->num_slice_groups_minus1, partition);
// FMO stuff
if(pps->num_slice_groups_minus1 > 0 )
{
len+=ue_v ("PPS: slice_group_map_type", pps->slice_group_map_type, partition);
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], partition);
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], partition);
len+=ue_v ("PPS: bottom_right[i]", pps->bottom_right[i], partition);
}
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, partition);
len+=ue_v ("PPS: slice_group_change_rate_minus1", pps->slice_group_change_rate_minus1, partition);
}
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: num_slice_group_map_units_minus1", pps->num_slice_group_map_units_minus1, partition);
for(i=0; i<=pps->num_slice_group_map_units_minus1; i++)
len+= u_v (NumberBitsPerSliceGroupId, "PPS: >slice_group_id[i]", pps->slice_group_id[i], partition);
}
}
// End of FMO stuff
len+=ue_v ("PPS: num_ref_idx_l0_active_minus1", pps->num_ref_idx_l0_active_minus1, partition);
len+=ue_v ("PPS: num_ref_idx_l1_active_minus1", pps->num_ref_idx_l1_active_minus1, partition);
len+=u_1 ("PPS: weighted_pred_flag", pps->weighted_pred_flag, partition);
len+=u_v (2, "PPS: weighted_bipred_idc", pps->weighted_bipred_idc, partition);
len+=se_v ("PPS: pic_init_qp_minus26", pps->pic_init_qp_minus26, partition);
len+=se_v ("PPS: pic_init_qs_minus26", pps->pic_init_qs_minus26, partition);
len+=se_v ("PPS: chroma_qp_index_offset", pps->chroma_qp_index_offset, partition);
len+=u_1 ("PPS: deblocking_filter_control_present_flag", pps->deblocking_filter_control_present_flag, partition);
len+=u_1 ("PPS: constrained_intra_pred_flag", pps->constrained_intra_pred_flag, partition);
len+=u_1 ("PPS: redundant_pic_cnt_present_flag", pps->redundant_pic_cnt_present_flag, partition);
#ifndef G50_SPS
len+=u_1 ("PPS: frame_cropping_flag", pps->frame_cropping_flag, partition);
if (pps->frame_cropping_flag)
{
len+=ue_v ("PPS: frame_cropping_rect_left_offset", pps->frame_cropping_rect_left_offset, partition);
len+=ue_v ("PPS: frame_cropping_rect_right_offset", pps->frame_cropping_rect_right_offset, partition);
len+=ue_v ("PPS: frame_cropping_rect_top_offset", pps->frame_cropping_rect_top_offset, partition);
len+=ue_v ("PPS: frame_cropping_rect_bottom_offset", pps->frame_cropping_rect_bottom_offset, partition);
}
#endif
SODBtoRBSP(partition->bitstream); // copies the last couple of bits into the byte buffer
LenInBytes=partition->bitstream->byte_pos;
// Get rid of the helper structures
free (partition->bitstream);
free (partition);
return LenInBytes;
}
/*!
*************************************************************************************
* \brief
* Returns the Profile
*
* \param none
*
* \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()
{
return PROFILE_IDC; // Baseline
};
/*!
*************************************************************************************
* \brief
* Returns the Level
*
* \param none
*
* \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()
{
return LEVEL_IDC;
};
/*!
*************************************************************************************
* \brief
* Returns the number of reference frame buffers
*
* \param none
*
* \return
* Number of reference frame buffers used
*
* \note
* This function currently maps to input->num_reference_frames. With all this interlace
* stuff this may or may not be correct. If you determine a problem with the
* memory management for Interlace, then this could be one possible problem.
* However, so far no problem have been determined by my limited testing of
* a stupid 1950's technology :-) StW, 11/27/02
*************************************************************************************
*/
int IdentifyNumRefFrames()
{
return input->num_reference_frames;
}
static int GenerateVUISequenceParameters()
{
printf ("Sequence Parameter VUI not yet implemented, this should never happen, exit\n");
exit (-1);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -