From 86b45819709ccc63d937c2fbdc76057e80fc15f5 Mon Sep 17 00:00:00 2001 From: Wind Yuan Date: Sun, 29 Jul 2012 22:03:08 -0400 Subject: [PATCH] h264 encoder: compiling passed with libva staging branch --- gst-libs/gst/vaapi/gstvaapiencoder_h264.c | 223 ++++++++++++++++++++---------- 1 file changed, 150 insertions(+), 73 deletions(-) diff --git a/gst-libs/gst/vaapi/gstvaapiencoder_h264.c b/gst-libs/gst/vaapi/gstvaapiencoder_h264.c index 01c5962..a635bd1 100644 --- a/gst-libs/gst/vaapi/gstvaapiencoder_h264.c +++ b/gst-libs/gst/vaapi/gstvaapiencoder_h264.c @@ -24,7 +24,8 @@ #include #include #include -#include "va/va_x11.h" +#include +#include #include #include @@ -121,6 +122,9 @@ struct _GstVaapiEncoderH264Private { guint32 cur_decode_num; H264_SLICE_TYPE cur_slice_type; guint64 last_decode_time; + guint32 max_frame_num; + guint32 max_pic_order_cnt; + guint16 idr_num; }; G_DEFINE_TYPE(GstVaapiEncoderH264, gst_vaapi_encoder_h264, GST_TYPE_VAAPI_BASE_ENCODER); @@ -182,7 +186,8 @@ static gboolean h264_bitstream_write_trailing_bits(H264Bitstream *bitstream); static gboolean h264_bitstream_write_byte_array(H264Bitstream *bitstream, const guint8 *buf, guint32 byte_size); static void h264_bitstream_destroy(H264Bitstream *bitstream, gboolean free_flag); static gboolean h264_bitstream_auto_grow(H264Bitstream *bitstream, guint32 extra_bit_size); -static gboolean h264_bitstream_write_sps(H264Bitstream *bitstream, VAEncSequenceParameterBufferH264 *seq); +static gboolean h264_bitstream_write_sps(H264Bitstream *bitstream, + VAEncSequenceParameterBufferH264 *seq, H264_Profile profile); static gboolean h264_bitstream_write_pps(H264Bitstream *bitstream, VAEncPictureParameterBufferH264 *pic); static gboolean h264_bitstream_write_nal_header(H264Bitstream *bitstream, guint nal_ref_idc, guint nal_unit_type); @@ -283,6 +288,10 @@ gst_vaapi_encoder_h264_init(GstVaapiEncoderH264 *encoder) h264_prv->cur_slice_type = SLICE_TYPE_I; h264_prv->last_decode_time = 0LL; h264_prv->default_cts_offset = 0; + + h264_prv->max_frame_num = 0; + h264_prv->max_pic_order_cnt = 0; + h264_prv->idr_num = 0; } static void @@ -608,6 +617,7 @@ gst_vaapi_encoder_h264_prepare_next_buffer(GstVaapiBaseEncoder* encoder, h264_prv->cur_display_num = 0; h264_prv->cur_decode_num = 0; h264_prv->cur_slice_type = SLICE_TYPE_I; + ++h264_prv->idr_num; return_buf = display_buf; goto end; } @@ -828,38 +838,44 @@ h264_recreate_seq_param(GstVaapiEncoderH264 *h264_encoder, height_in_mbs = (ENCODER_HEIGHT(h264_encoder)+15)/16; seq_h264.seq_parameter_set_id = 0; - seq_h264.profile_idc = h264_encoder->profile; seq_h264.level_idc = h264_encoder->level; /* 3.0 */ seq_h264.intra_period = h264_encoder->intra_period; seq_h264.ip_period = 0; // ? - seq_h264.max_num_ref_frames = (h264_encoder->b_frame_num < 2 ? 3 : h264_encoder->b_frame_num+1); // ?, why 4 - seq_h264.picture_width_in_mbs = width_in_mbs; - seq_h264.picture_height_in_mbs = height_in_mbs; - seq_h264.frame_mbs_only_flag = 1; - seq_h264.target_usage = 1; // ? - - if (h264_encoder->init_qp == -1) - seq_h264.rate_control_method = BR_CBR; - else if (h264_encoder->init_qp == -2) - seq_h264.rate_control_method = BR_VBR; - else { - ENCODER_ASSERT(h264_encoder->init_qp >= 0 && h264_encoder->init_qp <= 51); - seq_h264.rate_control_method = BR_CQP; - } - if (h264_encoder->bitrate> 0) seq_h264.bits_per_second = h264_encoder->bitrate; /* use kbps as input */ else seq_h264.bits_per_second = 0; - if (seq_h264.rate_control_method == BR_VBR) { - seq_h264.max_bits_per_second = seq_h264.bits_per_second*1.5; - seq_h264.min_bits_per_second = seq_h264.bits_per_second*0.3; - } - seq_h264.initial_hrd_buffer_fullness = 0; // ?? - seq_h264.hrd_buffer_size = 0; - seq_h264.num_units_in_tick = 100; - seq_h264.time_scale = ENCODER_FPS(h264_encoder)*2*seq_h264.num_units_in_tick; + seq_h264.max_num_ref_frames = (h264_encoder->b_frame_num < 2 ? 3 : h264_encoder->b_frame_num+1); // ?, why 4 + seq_h264.picture_width_in_mbs = width_in_mbs; + seq_h264.picture_height_in_mbs = height_in_mbs; + + /*sequence field values*/ + seq_h264.seq_fields.value = 0; + seq_h264.seq_fields.bits.chroma_format_idc = 1; + seq_h264.seq_fields.bits.frame_mbs_only_flag = 1; + seq_h264.seq_fields.bits.mb_adaptive_frame_field_flag = FALSE; + seq_h264.seq_fields.bits.seq_scaling_matrix_present_flag = FALSE; + /* direct_8x8_inference_flag default false */ + seq_h264.seq_fields.bits.direct_8x8_inference_flag = FALSE; + seq_h264.seq_fields.bits.log2_max_frame_num_minus4 = 4; // log2(seq_h264.intra_period)-3 : 0 + /* picture order count */ + seq_h264.seq_fields.bits.pic_order_cnt_type = 0; + seq_h264.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = + seq_h264.seq_fields.bits.log2_max_frame_num_minus4 + 2; + seq_h264.seq_fields.bits.delta_pic_order_always_zero_flag = TRUE; + + h264_prv->max_frame_num = 1<<(seq_h264.seq_fields.bits.log2_max_frame_num_minus4 + 4); + h264_prv->max_pic_order_cnt = 1 <<(seq_h264.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 + 4); + + seq_h264.bit_depth_luma_minus8 = 0; + seq_h264.bit_depth_chroma_minus8 = 0; + + /* not used if pic_order_cnt_type == 0 */ + seq_h264.num_ref_frames_in_pic_order_cnt_cycle = 0; + seq_h264.offset_for_non_ref_pic = 0; + seq_h264.offset_for_top_to_bottom_field = 0; + memset(seq_h264.offset_for_ref_frame, 0, sizeof(seq_h264.offset_for_ref_frame)); if (height_in_mbs*16 - ENCODER_HEIGHT(h264_encoder)) { seq_h264.frame_cropping_flag = 1; @@ -867,13 +883,21 @@ h264_recreate_seq_param(GstVaapiEncoderH264 *h264_encoder, seq_h264.frame_crop_right_offset = 0; seq_h264.frame_crop_top_offset = 0; seq_h264.frame_crop_bottom_offset = - (height_in_mbs * 16 - ENCODER_HEIGHT(h264_encoder))/(2 * (!seq_h264.frame_mbs_only_flag + 1)); + (height_in_mbs * 16 - ENCODER_HEIGHT(h264_encoder))/(2 * (!seq_h264.seq_fields.bits.frame_mbs_only_flag + 1)); + } +#if 0 + if (h264_encoder->init_qp == -1) + seq_h264.rate_control_method = BR_CBR; + else if (h264_encoder->init_qp == -2) + seq_h264.rate_control_method = BR_VBR; + else { + ENCODER_ASSERT(h264_encoder->init_qp >= 0 && h264_encoder->init_qp <= 51); + seq_h264.rate_control_method = BR_CQP; } - seq_h264.pic_order_cnt_type = 0; // pic order cnt - seq_h264.direct_8x8_inference_flag = 0; - seq_h264.log2_max_frame_num_minus4 = 4; // log2(seq_h264.intra_period)-3 : 0 - seq_h264.log2_max_pic_order_cnt_lsb_minus4 = seq_h264.log2_max_frame_num_minus4+2; - seq_h264.vui_flag = 0; // 0? or 1? +#endif + + /*vui not set*/ + seq_h264.vui_parameters_present_flag = 0; va_status = vaCreateBuffer(va_dpy, context_id, VAEncSequenceParameterBufferType, @@ -882,6 +906,7 @@ h264_recreate_seq_param(GstVaapiEncoderH264 *h264_encoder, ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, FALSE, "alloc seq-buffer failed."); +#if 0 /*pack sps header buffer/data */ if (NULL == h264_prv->sps_data) { VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 }; @@ -926,6 +951,7 @@ h264_recreate_seq_param(GstVaapiEncoderH264 *h264_encoder, FALSE, "EncPackedSeqHeaderDataBuffer failed"); } +#endif end: return ret; @@ -948,24 +974,33 @@ h264_recreate_pic_param(GstVaapiEncoderH264 *h264_encoder, pic_h264.ReferenceFrames[0].picture_id = GST_VAAPI_OBJECT_ID(h264_prv->ref_surface1); pic_h264.ReferenceFrames[1].picture_id = GST_VAAPI_OBJECT_ID(h264_prv->ref_surface2); pic_h264.ReferenceFrames[2].picture_id = VA_INVALID_ID; - pic_h264.CodedBuf = coded_buf; - - pic_h264.seq_parameter_set_id = 0; + pic_h264.coded_buf = coded_buf; pic_h264.pic_parameter_set_id = 0; - pic_h264.last_picture = 0; + pic_h264.seq_parameter_set_id = 0; + pic_h264.last_picture = 0; /* means last encoding picture */ pic_h264.frame_num = (h264_prv->cur_slice_type == SLICE_TYPE_B ? (h264_prv->cur_decode_num + 1) : h264_prv->cur_decode_num); - pic_h264.coding_type = 0; + //pic_h264.coding_type = 0; pic_h264.pic_init_qp = (h264_encoder->init_qp >= 0 ? h264_encoder->init_qp : 26); - pic_h264.num_ref_idx_l0_active_minus1 = 0; - pic_h264.num_ref_idx_l1_active_minus1 = 0; + pic_h264.num_ref_idx_l0_active_minus1 = 0; /* only 1 reference */ + pic_h264.num_ref_idx_l1_active_minus1 = 0; /* B frames only have 1 backward and 1 forward reference*/ + pic_h264.chroma_qp_index_offset = 0; + pic_h264.second_chroma_qp_index_offset = 0; + + /* set picture fields */ + pic_h264.pic_fields.value = 0; pic_h264.pic_fields.bits.idr_pic_flag = (h264_prv->cur_slice_type == SLICE_TYPE_I); pic_h264.pic_fields.bits.reference_pic_flag = (h264_prv->cur_slice_type != SLICE_TYPE_B); pic_h264.pic_fields.bits.entropy_coding_mode_flag = ENTROPY_MODE_CABAC; - pic_h264.pic_fields.bits.weighted_pred_flag = 0; + pic_h264.pic_fields.bits.weighted_pred_flag = FALSE; pic_h264.pic_fields.bits.weighted_bipred_idc = 0; - pic_h264.pic_fields.bits.transform_8x8_mode_flag = 1; - pic_h264.pic_fields.bits.deblocking_filter_control_present_flag = 1; + pic_h264.pic_fields.bits.constrained_intra_pred_flag = 0; + pic_h264.pic_fields.bits.transform_8x8_mode_flag = TRUE; /* enable 8x8 */ + pic_h264.pic_fields.bits.deblocking_filter_control_present_flag = TRUE; /* enable debloking */ + pic_h264.pic_fields.bits.redundant_pic_cnt_present_flag = FALSE; + /* bottom_field_pic_order_in_frame_present_flag */ + pic_h264.pic_fields.bits.pic_order_present_flag = FALSE; + pic_h264.pic_fields.bits.pic_scaling_matrix_present_flag = FALSE; char *frame_type = "I"; if (h264_prv->cur_slice_type == SLICE_TYPE_P) @@ -984,7 +1019,7 @@ h264_recreate_pic_param(GstVaapiEncoderH264 *h264_encoder, ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, FALSE, "creating pic-param buffer failed."); - +#if 0 //if (NULL == h264_prv->pps_data) { if (VA_INVALID_ID == h264_prv->packed_pps_data_buf) { VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 }; @@ -1031,7 +1066,7 @@ h264_recreate_pic_param(GstVaapiEncoderH264 *h264_encoder, FALSE, "EncPackedPicHeaderDataBuffer failed"); } - +#endif end: return ret; } @@ -1055,30 +1090,70 @@ h264_recreate_slice_param(GstVaapiEncoderH264 *h264_encoder, memset(h264_prv->slice_param_buffers, 0, h264_encoder->slice_num*sizeof(h264_prv->slice_param_buffers[0])); for (i = 0; i < h264_encoder->slice_num; ++i) { + int i_pic = 0; slice_h264 = &h264_prv->slice_param_buffers[i]; - slice_h264->starting_macroblock_address = last_row_num*width_in_mbs; - slice_h264->number_of_mbs = width_in_mbs*h264_prv->default_slice_height; + slice_h264->macroblock_address = last_row_num*width_in_mbs; + slice_h264->num_macroblocks = width_in_mbs*h264_prv->default_slice_height; last_row_num += h264_prv->default_slice_height; if (slice_mod_num) { - slice_h264->number_of_mbs += width_in_mbs; + slice_h264->num_macroblocks += width_in_mbs; ++last_row_num; --slice_mod_num; } - slice_h264->pic_parameter_set_id = 0; + slice_h264->macroblock_info = VA_INVALID_ID; slice_h264->slice_type = h264_prv->cur_slice_type; - slice_h264->direct_spatial_mv_pred_flag = 0; + slice_h264->pic_parameter_set_id = 0; + slice_h264->idr_pic_id = h264_prv->idr_num; + slice_h264->pic_order_cnt_lsb = (h264_prv->cur_display_num*2) % h264_prv->max_pic_order_cnt; + + /* not used if pic_order_cnt_type = 0 */ + slice_h264->delta_pic_order_cnt_bottom = 0; + memset(slice_h264->delta_pic_order_cnt, 0, sizeof(slice_h264->delta_pic_order_cnt)); + + /*only works for B frames*/ + slice_h264->direct_spatial_mv_pred_flag = FALSE; + /* default equal to picture parameters */ + slice_h264->num_ref_idx_active_override_flag = FALSE; slice_h264->num_ref_idx_l0_active_minus1 = 0; slice_h264->num_ref_idx_l1_active_minus1 = 0; + + slice_h264->RefPicList0[0].picture_id = GST_VAAPI_OBJECT_ID(h264_prv->ref_surface1); + for (i_pic = 1; + i_pic < sizeof(slice_h264->RefPicList0)/sizeof(slice_h264->RefPicList0[0]); + i_pic++) { + slice_h264->RefPicList0[i_pic].picture_id = VA_INVALID_ID; + } + + if (SLICE_TYPE_B == h264_prv->cur_slice_type) { + slice_h264->RefPicList1[0].picture_id = GST_VAAPI_OBJECT_ID(h264_prv->ref_surface2); + i_pic = 1; + } else + i_pic = 0; + for (; i_pic < sizeof(slice_h264->RefPicList1)/sizeof(slice_h264->RefPicList1[0]); i_pic++) + slice_h264->RefPicList1[i_pic].picture_id = VA_INVALID_ID; + + /* not used if pic_h264.pic_fields.bits.weighted_pred_flag == FALSE */ + slice_h264->luma_log2_weight_denom = 0; + slice_h264->chroma_log2_weight_denom = 0; + slice_h264->luma_weight_l0_flag = FALSE; + memset(slice_h264->luma_weight_l0, 0, sizeof(slice_h264->luma_weight_l0)); + memset(slice_h264->luma_offset_l0, 0, sizeof(slice_h264->luma_offset_l0)); + slice_h264->chroma_weight_l0_flag = FALSE; + memset(slice_h264->chroma_weight_l0, 0, sizeof(slice_h264->chroma_weight_l0)); + memset(slice_h264->chroma_offset_l0, 0, sizeof(slice_h264->chroma_offset_l0)); + slice_h264->luma_weight_l1_flag = FALSE; + memset(slice_h264->luma_weight_l1, 0, sizeof(slice_h264->luma_weight_l1)); + memset(slice_h264->luma_offset_l1, 0, sizeof(slice_h264->luma_offset_l1)); + slice_h264->chroma_weight_l1_flag = FALSE; + memset(slice_h264->chroma_weight_l1, 0, sizeof(slice_h264->chroma_weight_l1)); + memset(slice_h264->chroma_offset_l1, 0, sizeof(slice_h264->chroma_offset_l1)); + slice_h264->cabac_init_idc = 0; slice_h264->slice_qp_delta = 0; slice_h264->disable_deblocking_filter_idc = 0; slice_h264->slice_alpha_c0_offset_div2 = 2; slice_h264->slice_beta_offset_div2 = 2; - slice_h264->idr_pic_id = 0; - - slice_h264->ref_pic_list_modification_flag_l0 = 0; - slice_h264->ref_pic_list_modification_flag_l1 = 0; } ENCODER_ASSERT(last_row_num == (ENCODER_HEIGHT(h264_encoder)+15)/16); @@ -1598,7 +1673,8 @@ h264_bitstream_write_uint(H264Bitstream *bitstream, guint32 value, guint32 bit_s return ret; } -static gboolean h264_bitstream_align(H264Bitstream *bitstream, guint32 value) +static gboolean +h264_bitstream_align(H264Bitstream *bitstream, guint32 value) { guint32 bit_offset, bit_left; @@ -1733,25 +1809,25 @@ h264_bitstream_write_nal_header(H264Bitstream *bitstream, static gboolean h264_bitstream_write_sps(H264Bitstream *bitstream, - VAEncSequenceParameterBufferH264 *seq) + VAEncSequenceParameterBufferH264 *seq, H264_Profile profile) { guint32 constraint_set0_flag, constraint_set1_flag, constraint_set2_flag, constraint_set3_flag; guint32 gaps_in_frame_num_value_allowed_flag = 0; // ?? - guint32 b_qpprime_y_zero_transform_bypass = (seq->rate_control_method == BR_CQP); + guint32 b_qpprime_y_zero_transform_bypass = 0; guint32 residual_color_transform_flag = 0; - guint32 pic_height_in_map_units = (seq->frame_mbs_only_flag ? + guint32 pic_height_in_map_units = (seq->seq_fields.bits.frame_mbs_only_flag ? seq->picture_height_in_mbs : seq->picture_height_in_mbs/2); - guint32 mb_adaptive_frame_field = !seq->frame_mbs_only_flag; + guint32 mb_adaptive_frame_field = !seq->seq_fields.bits.frame_mbs_only_flag; guint32 i = 0; - constraint_set0_flag = seq->profile_idc == H264_PROFILE_BASELINE; - constraint_set1_flag = seq->profile_idc <= H264_PROFILE_MAIN; + constraint_set0_flag = profile == H264_PROFILE_BASELINE; + constraint_set1_flag = profile <= H264_PROFILE_MAIN; constraint_set2_flag = 0; constraint_set3_flag = 0; - h264_bitstream_write_uint(bitstream, seq->profile_idc, 8); /* profile_idc */ + h264_bitstream_write_uint(bitstream, profile, 8); /* profile_idc */ h264_bitstream_write_uint(bitstream, constraint_set0_flag, 1); /* constraint_set0_flag */ h264_bitstream_write_uint(bitstream, constraint_set1_flag, 1); /* constraint_set1_flag */ h264_bitstream_write_uint(bitstream, constraint_set2_flag, 1); /* constraint_set2_flag */ @@ -1760,7 +1836,7 @@ h264_bitstream_write_sps(H264Bitstream *bitstream, h264_bitstream_write_uint(bitstream, seq->level_idc, 8); /* level_idc */ h264_bitstream_write_ue(bitstream, seq->seq_parameter_set_id); /* seq_parameter_set_id */ - if (seq->profile_idc >= H264_PROFILE_HIGH) { + if (profile >= H264_PROFILE_HIGH) { /* for high profile */ ENCODER_ASSERT(0); h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.chroma_format_idc); /* chroma_format_idc = 1, 4:2:0*/ @@ -1773,6 +1849,7 @@ h264_bitstream_write_sps(H264Bitstream *bitstream, ENCODER_ASSERT(seq->seq_fields.bits.seq_scaling_matrix_present_flag == 0); h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.seq_scaling_matrix_present_flag, 1); /*seq_scaling_matrix_present_flag */ + #if 0 if (seq->seq_fields.bits.seq_scaling_matrix_present_flag) { for (i = 0; i < (seq->seq_fields.bits.chroma_format_idc != 3 ? 8 : 12); i++) { h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.seq_scaling_list_present_flag, 1); @@ -1782,14 +1859,15 @@ h264_bitstream_write_sps(H264Bitstream *bitstream, } } } + #endif } - h264_bitstream_write_ue(bitstream, seq->log2_max_frame_num_minus4); /* log2_max_frame_num_minus4 */ - h264_bitstream_write_ue(bitstream, seq->pic_order_cnt_type); /* pic_order_cnt_type */ + h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.log2_max_frame_num_minus4); /* log2_max_frame_num_minus4 */ + h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.pic_order_cnt_type); /* pic_order_cnt_type */ - if (seq->pic_order_cnt_type == 0) - h264_bitstream_write_ue(bitstream, seq->log2_max_pic_order_cnt_lsb_minus4);/* log2_max_pic_order_cnt_lsb_minus4 */ - else if (seq->pic_order_cnt_type == 1) { + if (seq->seq_fields.bits.pic_order_cnt_type == 0) + h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);/* log2_max_pic_order_cnt_lsb_minus4 */ + else if (seq->seq_fields.bits.pic_order_cnt_type == 1) { ENCODER_ASSERT(0); h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.delta_pic_order_always_zero_flag, 1); h264_bitstream_write_se(bitstream, seq->offset_for_non_ref_pic); @@ -1805,9 +1883,9 @@ h264_bitstream_write_sps(H264Bitstream *bitstream, h264_bitstream_write_ue(bitstream, seq->picture_width_in_mbs - 1); /* pic_width_in_mbs_minus1 */ h264_bitstream_write_ue(bitstream, pic_height_in_map_units - 1); /* pic_height_in_map_units_minus1 */ - h264_bitstream_write_uint(bitstream, seq->frame_mbs_only_flag, 1); /* frame_mbs_only_flag */ + h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.frame_mbs_only_flag, 1); /* frame_mbs_only_flag */ - if (!seq->frame_mbs_only_flag) { //ONLY mbs + if (!seq->seq_fields.bits.frame_mbs_only_flag) { //ONLY mbs ENCODER_ASSERT(0); h264_bitstream_write_uint(bitstream, mb_adaptive_frame_field, 1); } @@ -1821,16 +1899,15 @@ h264_bitstream_write_sps(H264Bitstream *bitstream, h264_bitstream_write_ue(bitstream, seq->frame_crop_top_offset); /* frame_crop_top_offset */ h264_bitstream_write_ue(bitstream, seq->frame_crop_bottom_offset); /* frame_crop_bottom_offset */ } - ENCODER_ASSERT(seq->vui_flag == 0); - h264_bitstream_write_uint(bitstream, seq->vui_flag, 1); /* vui_parameters_present_flag */ - if (seq->vui_flag) { + ENCODER_ASSERT(seq->vui_parameters_present_flag == FALSE); + h264_bitstream_write_uint(bitstream, seq->vui_parameters_present_flag, 1); /* vui_parameters_present_flag */ + if (seq->vui_parameters_present_flag) { /*FIXME, to write vui parameters*/ } h264_bitstream_write_trailing_bits(bitstream); /* rbsp_trailing_bits */ return TRUE; } - static gboolean h264_bitstream_write_pps(H264Bitstream *bitstream, VAEncPictureParameterBufferH264 *pic) -- 2.7.4