From 45732dcc831e20349d2b7d3c8600a604c079ceb1 Mon Sep 17 00:00:00 2001 From: Gwenole Beauchesne Date: Fri, 10 Jan 2014 14:05:40 +0100 Subject: [PATCH] encoder: h264: clean-ups. Various clean-ups to improve consistency and readability: rename some variables, drop unused macro definitions, drop initialization of vars that are zero-initialized from the base class, drop un-necessary casts. --- gst-libs/gst/vaapi/gstvaapiencoder_h264.c | 551 +++++++++--------- gst-libs/gst/vaapi/gstvaapiencoder_h264.h | 3 + .../gst/vaapi/gstvaapiencoder_h264_priv.h | 33 +- gst/vaapi/gstvaapiencode_h264.c | 4 +- 4 files changed, 286 insertions(+), 305 deletions(-) diff --git a/gst-libs/gst/vaapi/gstvaapiencoder_h264.c b/gst-libs/gst/vaapi/gstvaapiencoder_h264.c index 050c144176..7e4b6fd8f3 100644 --- a/gst-libs/gst/vaapi/gstvaapiencoder_h264.c +++ b/gst-libs/gst/vaapi/gstvaapiencoder_h264.c @@ -1,7 +1,7 @@ /* * gstvaapiencoder_h264.c - H.264 encoder * - * Copyright (C) 2012 -2013 Intel Corporation + * Copyright (C) 2012-2013 Intel Corporation * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -20,18 +20,14 @@ */ #include "sysdeps.h" +#include +#include +#include #include "gstvaapicompat.h" #include "gstvaapiencoder_h264.h" #include "gstvaapiencoder_h264_priv.h" -#include "gstvaapiencoder_priv.h" #include "gstvaapicodedbufferproxy_priv.h" - -#include -#include - -#include "gstvaapicontext.h" #include "gstvaapisurface.h" -#include "gstvaapidisplay_priv.h" #define DEBUG 1 #include "gstvaapidebug.h" @@ -99,8 +95,9 @@ _poc_greater_than (guint poc1, guint poc2, guint max_poc) return (((poc1 - poc2) & (max_poc - 1)) < max_poc / 2); } -static inline guint8 -_get_va_slice_type (GstVaapiPictureType type) +/* Get slice_type value for H.264 specification */ +static guint8 +h264_get_slice_type (GstVaapiPictureType type) { switch (type) { case GST_VAAPI_PICTURE_TYPE_I: @@ -132,8 +129,9 @@ _read_sps_attributes (const guint8 * sps_data, return TRUE; } -static inline guint -_get_log2_max_frame_num (guint num) +/* Get log2_max_frame_num value for H.264 specification */ +static guint +h264_get_log2_max_frame_num (guint num) { guint ret = 0; @@ -201,18 +199,18 @@ _set_level (GstVaapiEncoderH264 * encoder) guint MaxDpbMbs, MaxMBPS; guint dbp_level, mbps_level, profile_level; - if (encoder->level) { - if (encoder->level < GST_VAAPI_ENCODER_H264_LEVEL_10) - encoder->level = GST_VAAPI_ENCODER_H264_LEVEL_10; - else if (encoder->level > GST_VAAPI_ENCODER_H264_LEVEL_51) - encoder->level = GST_VAAPI_ENCODER_H264_LEVEL_51; + if (encoder->level_idc) { + if (encoder->level_idc < GST_VAAPI_ENCODER_H264_LEVEL_10) + encoder->level_idc = GST_VAAPI_ENCODER_H264_LEVEL_10; + else if (encoder->level_idc > GST_VAAPI_ENCODER_H264_LEVEL_51) + encoder->level_idc = GST_VAAPI_ENCODER_H264_LEVEL_51; return; } /* calculate level */ pic_mb_size = ((GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16) * ((GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16); - MaxDpbMbs = pic_mb_size * ((encoder->b_frame_num) ? 2 : 1); + MaxDpbMbs = pic_mb_size * ((encoder->num_bframes) ? 2 : 1); MaxMBPS = pic_mb_size * GST_VAAPI_ENCODER_FPS_N (encoder) / GST_VAAPI_ENCODER_FPS_D (encoder); @@ -275,9 +273,9 @@ _set_level (GstVaapiEncoderH264 * encoder) else profile_level = GST_VAAPI_ENCODER_H264_LEVEL_20; - encoder->level = (dbp_level > mbps_level ? dbp_level : mbps_level); - if (encoder->level < profile_level) - encoder->level = profile_level; + encoder->level_idc = (dbp_level > mbps_level ? dbp_level : mbps_level); + if (encoder->level_idc < profile_level) + encoder->level_idc = profile_level; } static inline void @@ -394,7 +392,7 @@ gst_bit_writer_write_trailing_bits (GstBitWriter * bitwriter) static gboolean gst_bit_writer_write_sps (GstBitWriter * bitwriter, - VAEncSequenceParameterBufferH264 * seq, GstVaapiProfile profile) + const VAEncSequenceParameterBufferH264 * seq_param, GstVaapiProfile profile) { guint32 constraint_set0_flag, constraint_set1_flag; guint32 constraint_set2_flag, constraint_set3_flag; @@ -404,9 +402,10 @@ gst_bit_writer_write_sps (GstBitWriter * bitwriter, guint32 b_qpprime_y_zero_transform_bypass = 0; guint32 residual_color_transform_flag = 0; 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->seq_fields.bits.frame_mbs_only_flag; + (seq_param->seq_fields.bits.frame_mbs_only_flag ? + seq_param->picture_height_in_mbs : seq_param->picture_height_in_mbs / 2); + guint32 mb_adaptive_frame_field = + !seq_param->seq_fields.bits.frame_mbs_only_flag; guint32 i = 0; constraint_set0_flag = profile == GST_VAAPI_PROFILE_H264_BASELINE; @@ -427,37 +426,39 @@ gst_bit_writer_write_sps (GstBitWriter * bitwriter, /* reserved_zero_4bits */ gst_bit_writer_put_bits_uint32 (bitwriter, 0, 4); /* level_idc */ - gst_bit_writer_put_bits_uint32 (bitwriter, seq->level_idc, 8); + gst_bit_writer_put_bits_uint32 (bitwriter, seq_param->level_idc, 8); /* seq_parameter_set_id */ - gst_bit_writer_put_ue (bitwriter, seq->seq_parameter_set_id); + gst_bit_writer_put_ue (bitwriter, seq_param->seq_parameter_set_id); if (profile == GST_VAAPI_PROFILE_H264_HIGH) { /* for high profile */ /* chroma_format_idc = 1, 4:2:0 */ - gst_bit_writer_put_ue (bitwriter, seq->seq_fields.bits.chroma_format_idc); - if (3 == seq->seq_fields.bits.chroma_format_idc) { + gst_bit_writer_put_ue (bitwriter, + seq_param->seq_fields.bits.chroma_format_idc); + if (3 == seq_param->seq_fields.bits.chroma_format_idc) { gst_bit_writer_put_bits_uint32 (bitwriter, residual_color_transform_flag, 1); } /* bit_depth_luma_minus8 */ - gst_bit_writer_put_ue (bitwriter, seq->bit_depth_luma_minus8); + gst_bit_writer_put_ue (bitwriter, seq_param->bit_depth_luma_minus8); /* bit_depth_chroma_minus8 */ - gst_bit_writer_put_ue (bitwriter, seq->bit_depth_chroma_minus8); + gst_bit_writer_put_ue (bitwriter, seq_param->bit_depth_chroma_minus8); /* b_qpprime_y_zero_transform_bypass */ gst_bit_writer_put_bits_uint32 (bitwriter, b_qpprime_y_zero_transform_bypass, 1); - g_assert (seq->seq_fields.bits.seq_scaling_matrix_present_flag == 0); - /*seq_scaling_matrix_present_flag */ + g_assert (seq_param->seq_fields.bits.seq_scaling_matrix_present_flag == 0); + /* seq_scaling_matrix_present_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, - seq->seq_fields.bits.seq_scaling_matrix_present_flag, 1); + seq_param->seq_fields.bits.seq_scaling_matrix_present_flag, 1); #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); + if (seq_param->seq_fields.bits.seq_scaling_matrix_present_flag) { + for (i = 0; + i < (seq_param->seq_fields.bits.chroma_format_idc != 3 ? 8 : 12); i++) { gst_bit_writer_put_bits_uint8 (bitwriter, - seq->seq_fields.bits.seq_scaling_list_present_flag, 1); - if (seq->seq_fields.bits.seq_scaling_list_present_flag) { + seq_param->seq_fields.bits.seq_scaling_list_present_flag, 1); + if (seq_param->seq_fields.bits.seq_scaling_list_present_flag) { g_assert (0); /* FIXME, need write scaling list if seq_scaling_matrix_present_flag ==1 */ } @@ -468,42 +469,44 @@ gst_bit_writer_write_sps (GstBitWriter * bitwriter, /* log2_max_frame_num_minus4 */ gst_bit_writer_put_ue (bitwriter, - seq->seq_fields.bits.log2_max_frame_num_minus4); + seq_param->seq_fields.bits.log2_max_frame_num_minus4); /* pic_order_cnt_type */ - gst_bit_writer_put_ue (bitwriter, seq->seq_fields.bits.pic_order_cnt_type); + gst_bit_writer_put_ue (bitwriter, + seq_param->seq_fields.bits.pic_order_cnt_type); - if (seq->seq_fields.bits.pic_order_cnt_type == 0) { + if (seq_param->seq_fields.bits.pic_order_cnt_type == 0) { /* log2_max_pic_order_cnt_lsb_minus4 */ gst_bit_writer_put_ue (bitwriter, - seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4); - } else if (seq->seq_fields.bits.pic_order_cnt_type == 1) { + seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4); + } else if (seq_param->seq_fields.bits.pic_order_cnt_type == 1) { g_assert (0); gst_bit_writer_put_bits_uint32 (bitwriter, - seq->seq_fields.bits.delta_pic_order_always_zero_flag, 1); - gst_bit_writer_put_se (bitwriter, seq->offset_for_non_ref_pic); - gst_bit_writer_put_se (bitwriter, seq->offset_for_top_to_bottom_field); + seq_param->seq_fields.bits.delta_pic_order_always_zero_flag, 1); + gst_bit_writer_put_se (bitwriter, seq_param->offset_for_non_ref_pic); + gst_bit_writer_put_se (bitwriter, + seq_param->offset_for_top_to_bottom_field); gst_bit_writer_put_ue (bitwriter, - seq->num_ref_frames_in_pic_order_cnt_cycle); - for (i = 0; i < seq->num_ref_frames_in_pic_order_cnt_cycle; i++) { - gst_bit_writer_put_se (bitwriter, seq->offset_for_ref_frame[i]); + seq_param->num_ref_frames_in_pic_order_cnt_cycle); + for (i = 0; i < seq_param->num_ref_frames_in_pic_order_cnt_cycle; i++) { + gst_bit_writer_put_se (bitwriter, seq_param->offset_for_ref_frame[i]); } } /* num_ref_frames */ - gst_bit_writer_put_ue (bitwriter, seq->max_num_ref_frames); + gst_bit_writer_put_ue (bitwriter, seq_param->max_num_ref_frames); /* gaps_in_frame_num_value_allowed_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, gaps_in_frame_num_value_allowed_flag, 1); /* pic_width_in_mbs_minus1 */ - gst_bit_writer_put_ue (bitwriter, seq->picture_width_in_mbs - 1); + gst_bit_writer_put_ue (bitwriter, seq_param->picture_width_in_mbs - 1); /* pic_height_in_map_units_minus1 */ gst_bit_writer_put_ue (bitwriter, pic_height_in_map_units - 1); /* frame_mbs_only_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, - seq->seq_fields.bits.frame_mbs_only_flag, 1); + seq_param->seq_fields.bits.frame_mbs_only_flag, 1); - if (!seq->seq_fields.bits.frame_mbs_only_flag) { //ONLY mbs + if (!seq_param->seq_fields.bits.frame_mbs_only_flag) { //ONLY mbs g_assert (0); gst_bit_writer_put_bits_uint32 (bitwriter, mb_adaptive_frame_field, 1); } @@ -511,31 +514,32 @@ gst_bit_writer_write_sps (GstBitWriter * bitwriter, /* direct_8x8_inference_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, 0, 1); /* frame_cropping_flag */ - gst_bit_writer_put_bits_uint32 (bitwriter, seq->frame_cropping_flag, 1); + gst_bit_writer_put_bits_uint32 (bitwriter, seq_param->frame_cropping_flag, 1); - if (seq->frame_cropping_flag) { + if (seq_param->frame_cropping_flag) { /* frame_crop_left_offset */ - gst_bit_writer_put_ue (bitwriter, seq->frame_crop_left_offset); + gst_bit_writer_put_ue (bitwriter, seq_param->frame_crop_left_offset); /* frame_crop_right_offset */ - gst_bit_writer_put_ue (bitwriter, seq->frame_crop_right_offset); + gst_bit_writer_put_ue (bitwriter, seq_param->frame_crop_right_offset); /* frame_crop_top_offset */ - gst_bit_writer_put_ue (bitwriter, seq->frame_crop_top_offset); + gst_bit_writer_put_ue (bitwriter, seq_param->frame_crop_top_offset); /* frame_crop_bottom_offset */ - gst_bit_writer_put_ue (bitwriter, seq->frame_crop_bottom_offset); + gst_bit_writer_put_ue (bitwriter, seq_param->frame_crop_bottom_offset); } /* vui_parameters_present_flag */ - gst_bit_writer_put_bits_uint32 (bitwriter, seq->vui_parameters_present_flag, - 1); - if (seq->vui_parameters_present_flag) { + gst_bit_writer_put_bits_uint32 (bitwriter, + seq_param->vui_parameters_present_flag, 1); + if (seq_param->vui_parameters_present_flag) { /* aspect_ratio_info_present_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, - seq->vui_fields.bits.aspect_ratio_info_present_flag, 1); - if (seq->vui_fields.bits.aspect_ratio_info_present_flag) { - gst_bit_writer_put_bits_uint32 (bitwriter, seq->aspect_ratio_idc, 8); - if (seq->aspect_ratio_idc == 0xFF) { - gst_bit_writer_put_bits_uint32 (bitwriter, seq->sar_width, 16); - gst_bit_writer_put_bits_uint32 (bitwriter, seq->sar_height, 16); + seq_param->vui_fields.bits.aspect_ratio_info_present_flag, 1); + if (seq_param->vui_fields.bits.aspect_ratio_info_present_flag) { + gst_bit_writer_put_bits_uint32 (bitwriter, seq_param->aspect_ratio_idc, + 8); + if (seq_param->aspect_ratio_idc == 0xFF) { + gst_bit_writer_put_bits_uint32 (bitwriter, seq_param->sar_width, 16); + gst_bit_writer_put_bits_uint32 (bitwriter, seq_param->sar_height, 16); } } @@ -548,14 +552,16 @@ gst_bit_writer_write_sps (GstBitWriter * bitwriter, /* timing_info_present_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, - seq->vui_fields.bits.timing_info_present_flag, 1); - if (seq->vui_fields.bits.timing_info_present_flag) { - gst_bit_writer_put_bits_uint32 (bitwriter, seq->num_units_in_tick, 32); - gst_bit_writer_put_bits_uint32 (bitwriter, seq->time_scale, 32); + seq_param->vui_fields.bits.timing_info_present_flag, 1); + if (seq_param->vui_fields.bits.timing_info_present_flag) { + gst_bit_writer_put_bits_uint32 (bitwriter, seq_param->num_units_in_tick, + 32); + gst_bit_writer_put_bits_uint32 (bitwriter, seq_param->time_scale, 32); gst_bit_writer_put_bits_uint32 (bitwriter, 1, 1); /* fixed_frame_rate_flag */ } - nal_hrd_parameters_present_flag = (seq->bits_per_second > 0 ? TRUE : FALSE); + nal_hrd_parameters_present_flag = + (seq_param->bits_per_second > 0 ? TRUE : FALSE); /* nal_hrd_parameters_present_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, nal_hrd_parameters_present_flag, 1); @@ -568,9 +574,11 @@ gst_bit_writer_write_sps (GstBitWriter * bitwriter, for (i = 0; i < 1; ++i) { /* bit_rate_value_minus1[0] */ - gst_bit_writer_put_ue (bitwriter, seq->bits_per_second / 1000 - 1); + gst_bit_writer_put_ue (bitwriter, + seq_param->bits_per_second / 1000 - 1); /* cpb_size_value_minus1[0] */ - gst_bit_writer_put_ue (bitwriter, seq->bits_per_second / 1000 * 8 - 1); + gst_bit_writer_put_ue (bitwriter, + seq_param->bits_per_second / 1000 * 8 - 1); /* cbr_flag[0] */ gst_bit_writer_put_bits_uint32 (bitwriter, 1, 1); } @@ -603,65 +611,65 @@ gst_bit_writer_write_sps (GstBitWriter * bitwriter, static gboolean gst_bit_writer_write_pps (GstBitWriter * bitwriter, - VAEncPictureParameterBufferH264 * pic) + const VAEncPictureParameterBufferH264 * pic_param) { guint32 num_slice_groups_minus1 = 0; guint32 pic_init_qs_minus26 = 0; guint32 redundant_pic_cnt_present_flag = 0; /* pic_parameter_set_id */ - gst_bit_writer_put_ue (bitwriter, pic->pic_parameter_set_id); + gst_bit_writer_put_ue (bitwriter, pic_param->pic_parameter_set_id); /* seq_parameter_set_id */ - gst_bit_writer_put_ue (bitwriter, pic->seq_parameter_set_id); + gst_bit_writer_put_ue (bitwriter, pic_param->seq_parameter_set_id); /* entropy_coding_mode_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, - pic->pic_fields.bits.entropy_coding_mode_flag, 1); + pic_param->pic_fields.bits.entropy_coding_mode_flag, 1); /* pic_order_present_flag */ gst_bit_writer_put_bits_uint32 (bitwriter, - pic->pic_fields.bits.pic_order_present_flag, 1); - /*slice_groups-1 */ + pic_param->pic_fields.bits.pic_order_present_flag, 1); + /* slice_groups-1 */ gst_bit_writer_put_ue (bitwriter, num_slice_groups_minus1); if (num_slice_groups_minus1 > 0) { /*FIXME*/ g_assert (0); } - gst_bit_writer_put_ue (bitwriter, pic->num_ref_idx_l0_active_minus1); - gst_bit_writer_put_ue (bitwriter, pic->num_ref_idx_l1_active_minus1); + gst_bit_writer_put_ue (bitwriter, pic_param->num_ref_idx_l0_active_minus1); + gst_bit_writer_put_ue (bitwriter, pic_param->num_ref_idx_l1_active_minus1); gst_bit_writer_put_bits_uint32 (bitwriter, - pic->pic_fields.bits.weighted_pred_flag, 1); + pic_param->pic_fields.bits.weighted_pred_flag, 1); gst_bit_writer_put_bits_uint32 (bitwriter, - pic->pic_fields.bits.weighted_bipred_idc, 2); + pic_param->pic_fields.bits.weighted_bipred_idc, 2); /* pic_init_qp_minus26 */ - gst_bit_writer_put_se (bitwriter, pic->pic_init_qp - 26); + gst_bit_writer_put_se (bitwriter, pic_param->pic_init_qp - 26); /* pic_init_qs_minus26 */ gst_bit_writer_put_se (bitwriter, pic_init_qs_minus26); - /*chroma_qp_index_offset */ - gst_bit_writer_put_se (bitwriter, pic->chroma_qp_index_offset); + /* chroma_qp_index_offset */ + gst_bit_writer_put_se (bitwriter, pic_param->chroma_qp_index_offset); gst_bit_writer_put_bits_uint32 (bitwriter, - pic->pic_fields.bits.deblocking_filter_control_present_flag, 1); + pic_param->pic_fields.bits.deblocking_filter_control_present_flag, 1); gst_bit_writer_put_bits_uint32 (bitwriter, - pic->pic_fields.bits.constrained_intra_pred_flag, 1); + pic_param->pic_fields.bits.constrained_intra_pred_flag, 1); gst_bit_writer_put_bits_uint32 (bitwriter, redundant_pic_cnt_present_flag, 1); - /*more_rbsp_data */ + /* more_rbsp_data */ gst_bit_writer_put_bits_uint32 (bitwriter, - pic->pic_fields.bits.transform_8x8_mode_flag, 1); + pic_param->pic_fields.bits.transform_8x8_mode_flag, 1); gst_bit_writer_put_bits_uint32 (bitwriter, - pic->pic_fields.bits.pic_scaling_matrix_present_flag, 1); - if (pic->pic_fields.bits.pic_scaling_matrix_present_flag) { + pic_param->pic_fields.bits.pic_scaling_matrix_present_flag, 1); + if (pic_param->pic_fields.bits.pic_scaling_matrix_present_flag) { g_assert (0); /* FIXME */ /* for (i = 0; i < - (6+(-( (chroma_format_idc ! = 3) ? 2 : 6) * -pic->pic_fields.bits.transform_8x8_mode_flag)); + (6+(-( (chroma_format_idc ! = 3) ? 2 : 6) * -pic_param->pic_fields.bits.transform_8x8_mode_flag)); i++) { - gst_bit_writer_put_bits_uint8(bitwriter, pic->pic_fields.bits.pic_scaling_list_present_flag, 1); + gst_bit_writer_put_bits_uint8(bitwriter, pic_param->pic_fields.bits.pic_scaling_list_present_flag, 1); } */ } - gst_bit_writer_put_se (bitwriter, pic->second_chroma_qp_index_offset); + gst_bit_writer_put_se (bitwriter, pic_param->second_chroma_qp_index_offset); gst_bit_writer_write_trailing_bits (bitwriter); return TRUE; @@ -674,7 +682,7 @@ add_sequence_packed_header (GstVaapiEncoderH264 * encoder, GstVaapiEncPackedHeader *packed_seq; GstBitWriter writer; VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 }; - VAEncSequenceParameterBufferH264 *seq_param = sequence->param; + const VAEncSequenceParameterBufferH264 *const seq_param = sequence->param; guint32 data_bit_size; guint8 *data; @@ -697,11 +705,10 @@ add_sequence_packed_header (GstVaapiEncoderH264 * encoder, g_assert (packed_seq); gst_vaapi_enc_picture_add_packed_header (picture, packed_seq); - gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & packed_seq, NULL); + gst_vaapi_codec_object_replace (&packed_seq, NULL); /* store sps data */ _check_sps_pps_status (encoder, data + 4, data_bit_size / 8 - 4); - gst_bit_writer_clear (&writer, TRUE); return TRUE; @@ -714,7 +721,7 @@ add_picture_packed_header (GstVaapiEncoderH264 * encoder, GstVaapiEncPackedHeader *packed_pic; GstBitWriter writer; VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 }; - VAEncPictureParameterBufferH264 *pic_param = picture->param; + const VAEncPictureParameterBufferH264 *const pic_param = picture->param; guint32 data_bit_size; guint8 *data; @@ -737,7 +744,7 @@ add_picture_packed_header (GstVaapiEncoderH264 * encoder, g_assert (packed_pic); gst_vaapi_enc_picture_add_packed_header (picture, packed_pic); - gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & packed_pic, NULL); + gst_vaapi_codec_object_replace (&packed_pic, NULL); /* store pps data */ _check_sps_pps_status (encoder, data + 4, data_bit_size / 8 - 4); @@ -761,7 +768,7 @@ static inline GstVaapiEncoderH264Ref * reference_pic_create (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture, GstVaapiSurfaceProxy * surface) { - GstVaapiEncoderH264Ref *ref = g_slice_new0 (GstVaapiEncoderH264Ref); + GstVaapiEncoderH264Ref *const ref = g_slice_new0 (GstVaapiEncoderH264Ref); ref->pic = surface; ref->frame_num = picture->frame_num; @@ -782,12 +789,12 @@ reference_list_update (GstVaapiEncoderH264 * encoder, if (GST_VAAPI_ENC_PICTURE_IS_IDR (picture)) { while (!g_queue_is_empty (&encoder->ref_list)) reference_pic_free (encoder, g_queue_pop_head (&encoder->ref_list)); - } else if (g_queue_get_length (&encoder->ref_list) >= encoder->max_ref_num) { + } else if (g_queue_get_length (&encoder->ref_list) >= encoder->max_ref_frames) { reference_pic_free (encoder, g_queue_pop_head (&encoder->ref_list)); } ref = reference_pic_create (encoder, picture, surface); g_queue_push_tail (&encoder->ref_list, ref); - g_assert (g_queue_get_length (&encoder->ref_list) <= encoder->max_ref_num); + g_assert (g_queue_get_length (&encoder->ref_list) <= encoder->max_ref_frames); return TRUE; } @@ -849,75 +856,73 @@ fill_va_sequence_param (GstVaapiEncoderH264 * encoder, GstVaapiEncSequence * sequence) { GstVaapiEncoder *const base_encoder = GST_VAAPI_ENCODER_CAST (encoder); - VAEncSequenceParameterBufferH264 *seq = sequence->param; - guint width_in_mbs, height_in_mbs; + VAEncSequenceParameterBufferH264 *const seq_param = sequence->param; - width_in_mbs = (GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16; - height_in_mbs = (GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16; - - memset (seq, 0, sizeof (VAEncSequenceParameterBufferH264)); - seq->seq_parameter_set_id = 0; - seq->level_idc = encoder->level; - seq->intra_period = GST_VAAPI_ENCODER_KEYFRAME_PERIOD (encoder); - seq->ip_period = 0; // ? + memset (seq_param, 0, sizeof (VAEncSequenceParameterBufferH264)); + seq_param->seq_parameter_set_id = 0; + seq_param->level_idc = encoder->level_idc; + seq_param->intra_period = GST_VAAPI_ENCODER_KEYFRAME_PERIOD (encoder); + seq_param->ip_period = 0; // ? if (base_encoder->bitrate > 0) - seq->bits_per_second = base_encoder->bitrate * 1000; + seq_param->bits_per_second = base_encoder->bitrate * 1000; else - seq->bits_per_second = 0; + seq_param->bits_per_second = 0; - seq->max_num_ref_frames = encoder->max_ref_num; - seq->picture_width_in_mbs = width_in_mbs; - seq->picture_height_in_mbs = height_in_mbs; + seq_param->max_num_ref_frames = encoder->max_ref_frames; + seq_param->picture_width_in_mbs = encoder->mb_width; + seq_param->picture_height_in_mbs = encoder->mb_height; /*sequence field values */ - seq->seq_fields.value = 0; - seq->seq_fields.bits.chroma_format_idc = 1; - seq->seq_fields.bits.frame_mbs_only_flag = 1; - seq->seq_fields.bits.mb_adaptive_frame_field_flag = FALSE; - seq->seq_fields.bits.seq_scaling_matrix_present_flag = FALSE; + seq_param->seq_fields.value = 0; + seq_param->seq_fields.bits.chroma_format_idc = 1; + seq_param->seq_fields.bits.frame_mbs_only_flag = 1; + seq_param->seq_fields.bits.mb_adaptive_frame_field_flag = FALSE; + seq_param->seq_fields.bits.seq_scaling_matrix_present_flag = FALSE; /* direct_8x8_inference_flag default false */ - seq->seq_fields.bits.direct_8x8_inference_flag = FALSE; + seq_param->seq_fields.bits.direct_8x8_inference_flag = FALSE; g_assert (encoder->log2_max_frame_num >= 4); - seq->seq_fields.bits.log2_max_frame_num_minus4 = + seq_param->seq_fields.bits.log2_max_frame_num_minus4 = encoder->log2_max_frame_num - 4; /* picture order count */ - seq->seq_fields.bits.pic_order_cnt_type = 0; + seq_param->seq_fields.bits.pic_order_cnt_type = 0; g_assert (encoder->log2_max_pic_order_cnt >= 4); - seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = + seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = encoder->log2_max_pic_order_cnt - 4; - seq->bit_depth_luma_minus8 = 0; - seq->bit_depth_chroma_minus8 = 0; + seq_param->bit_depth_luma_minus8 = 0; + seq_param->bit_depth_chroma_minus8 = 0; /* not used if pic_order_cnt_type == 0 */ - if (seq->seq_fields.bits.pic_order_cnt_type == 1) { - seq->seq_fields.bits.delta_pic_order_always_zero_flag = TRUE; - seq->num_ref_frames_in_pic_order_cnt_cycle = 0; - seq->offset_for_non_ref_pic = 0; - seq->offset_for_top_to_bottom_field = 0; - memset (seq->offset_for_ref_frame, 0, sizeof (seq->offset_for_ref_frame)); + if (seq_param->seq_fields.bits.pic_order_cnt_type == 1) { + seq_param->seq_fields.bits.delta_pic_order_always_zero_flag = TRUE; + seq_param->num_ref_frames_in_pic_order_cnt_cycle = 0; + seq_param->offset_for_non_ref_pic = 0; + seq_param->offset_for_top_to_bottom_field = 0; + memset (seq_param->offset_for_ref_frame, 0, + sizeof (seq_param->offset_for_ref_frame)); } - if (height_in_mbs * 16 - GST_VAAPI_ENCODER_HEIGHT (encoder)) { - seq->frame_cropping_flag = 1; - seq->frame_crop_left_offset = 0; - seq->frame_crop_right_offset = 0; - seq->frame_crop_top_offset = 0; - seq->frame_crop_bottom_offset = - ((height_in_mbs * 16 - GST_VAAPI_ENCODER_HEIGHT (encoder)) / - (2 * (!seq->seq_fields.bits.frame_mbs_only_flag + 1))); + if (encoder->mb_height * 16 - GST_VAAPI_ENCODER_HEIGHT (encoder)) { + seq_param->frame_cropping_flag = 1; + seq_param->frame_crop_left_offset = 0; + seq_param->frame_crop_right_offset = 0; + seq_param->frame_crop_top_offset = 0; + seq_param->frame_crop_bottom_offset = + ((encoder->mb_height * 16 - GST_VAAPI_ENCODER_HEIGHT (encoder)) / + (2 * (!seq_param->seq_fields.bits.frame_mbs_only_flag + 1))); } - /*vui not set */ - seq->vui_parameters_present_flag = (base_encoder->bitrate > 0 ? TRUE : FALSE); - if (seq->vui_parameters_present_flag) { - seq->vui_fields.bits.aspect_ratio_info_present_flag = FALSE; - seq->vui_fields.bits.bitstream_restriction_flag = FALSE; - seq->vui_fields.bits.timing_info_present_flag = + /* vui not set */ + seq_param->vui_parameters_present_flag = + (base_encoder->bitrate > 0 ? TRUE : FALSE); + if (seq_param->vui_parameters_present_flag) { + seq_param->vui_fields.bits.aspect_ratio_info_present_flag = FALSE; + seq_param->vui_fields.bits.bitstream_restriction_flag = FALSE; + seq_param->vui_fields.bits.timing_info_present_flag = (base_encoder->bitrate > 0 ? TRUE : FALSE); - if (seq->vui_fields.bits.timing_info_present_flag) { - seq->num_units_in_tick = GST_VAAPI_ENCODER_FPS_D (encoder); - seq->time_scale = GST_VAAPI_ENCODER_FPS_N (encoder) * 2; + if (seq_param->vui_fields.bits.timing_info_present_flag) { + seq_param->num_units_in_tick = GST_VAAPI_ENCODER_FPS_D (encoder); + seq_param->time_scale = GST_VAAPI_ENCODER_FPS_N (encoder) * 2; } } @@ -929,16 +934,16 @@ fill_va_picture_param (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture, GstVaapiCodedBuffer * codedbuf, GstVaapiSurfaceProxy * surface) { - VAEncPictureParameterBufferH264 *pic = picture->param; + VAEncPictureParameterBufferH264 *const pic_param = picture->param; GstVaapiEncoderH264Ref *ref_pic; GList *reflist; guint i; - memset (pic, 0, sizeof (VAEncPictureParameterBufferH264)); + memset (pic_param, 0, sizeof (VAEncPictureParameterBufferH264)); /* reference list, */ - pic->CurrPic.picture_id = GST_VAAPI_SURFACE_PROXY_SURFACE_ID (surface); - pic->CurrPic.TopFieldOrderCnt = picture->poc; + pic_param->CurrPic.picture_id = GST_VAAPI_SURFACE_PROXY_SURFACE_ID (surface); + pic_param->CurrPic.TopFieldOrderCnt = picture->poc; i = 0; if (picture->type != GST_VAAPI_PICTURE_TYPE_I) { for (reflist = g_queue_peek_head_link (&encoder->ref_list); @@ -947,46 +952,47 @@ fill_va_picture_param (GstVaapiEncoderH264 * encoder, g_assert (ref_pic && ref_pic->pic && GST_VAAPI_SURFACE_PROXY_SURFACE_ID (ref_pic->pic) != VA_INVALID_ID); - pic->ReferenceFrames[i].picture_id = + pic_param->ReferenceFrames[i].picture_id = GST_VAAPI_SURFACE_PROXY_SURFACE_ID (ref_pic->pic); ++i; } - g_assert (i <= 16 && i <= encoder->max_ref_num); + g_assert (i <= 16 && i <= encoder->max_ref_frames); } for (; i < 16; ++i) { - pic->ReferenceFrames[i].picture_id = VA_INVALID_ID; + pic_param->ReferenceFrames[i].picture_id = VA_INVALID_ID; } - pic->coded_buf = GST_VAAPI_OBJECT_ID (codedbuf); + pic_param->coded_buf = GST_VAAPI_OBJECT_ID (codedbuf); - pic->pic_parameter_set_id = 0; - pic->seq_parameter_set_id = 0; - pic->last_picture = 0; /* means last encoding picture */ - pic->frame_num = picture->frame_num; - pic->pic_init_qp = encoder->init_qp; - pic->num_ref_idx_l0_active_minus1 = + pic_param->pic_parameter_set_id = 0; + pic_param->seq_parameter_set_id = 0; + pic_param->last_picture = 0; /* means last encoding picture */ + pic_param->frame_num = picture->frame_num; + pic_param->pic_init_qp = encoder->init_qp; + pic_param->num_ref_idx_l0_active_minus1 = (encoder->max_reflist0_count ? (encoder->max_reflist0_count - 1) : 0); - pic->num_ref_idx_l1_active_minus1 = + pic_param->num_ref_idx_l1_active_minus1 = (encoder->max_reflist1_count ? (encoder->max_reflist1_count - 1) : 0); - pic->chroma_qp_index_offset = 0; - pic->second_chroma_qp_index_offset = 0; + pic_param->chroma_qp_index_offset = 0; + pic_param->second_chroma_qp_index_offset = 0; /* set picture fields */ - pic->pic_fields.value = 0; - pic->pic_fields.bits.idr_pic_flag = GST_VAAPI_ENC_PICTURE_IS_IDR (picture); - pic->pic_fields.bits.reference_pic_flag = + pic_param->pic_fields.value = 0; + pic_param->pic_fields.bits.idr_pic_flag = + GST_VAAPI_ENC_PICTURE_IS_IDR (picture); + pic_param->pic_fields.bits.reference_pic_flag = (picture->type != GST_VAAPI_PICTURE_TYPE_B); - pic->pic_fields.bits.entropy_coding_mode_flag = + pic_param->pic_fields.bits.entropy_coding_mode_flag = GST_VAAPI_ENCODER_H264_ENTROPY_MODE_CABAC; - pic->pic_fields.bits.weighted_pred_flag = FALSE; - pic->pic_fields.bits.weighted_bipred_idc = 0; - pic->pic_fields.bits.constrained_intra_pred_flag = 0; - pic->pic_fields.bits.transform_8x8_mode_flag = (encoder->profile >= GST_VAAPI_PROFILE_H264_HIGH); /* enable 8x8 */ + pic_param->pic_fields.bits.weighted_pred_flag = FALSE; + pic_param->pic_fields.bits.weighted_bipred_idc = 0; + pic_param->pic_fields.bits.constrained_intra_pred_flag = 0; + pic_param->pic_fields.bits.transform_8x8_mode_flag = (encoder->profile >= GST_VAAPI_PROFILE_H264_HIGH); /* enable 8x8 */ /* enable debloking */ - pic->pic_fields.bits.deblocking_filter_control_present_flag = TRUE; - pic->pic_fields.bits.redundant_pic_cnt_present_flag = FALSE; + pic_param->pic_fields.bits.deblocking_filter_control_present_flag = TRUE; + pic_param->pic_fields.bits.redundant_pic_cnt_present_flag = FALSE; /* bottom_field_pic_order_in_frame_present_flag */ - pic->pic_fields.bits.pic_order_present_flag = FALSE; - pic->pic_fields.bits.pic_scaling_matrix_present_flag = FALSE; + pic_param->pic_fields.bits.pic_order_present_flag = FALSE; + pic_param->pic_fields.bits.pic_scaling_matrix_present_flag = FALSE; return TRUE; } @@ -1000,23 +1006,20 @@ fill_va_slices_param (GstVaapiEncoderH264 * encoder, { VAEncSliceParameterBufferH264 *slice_param; GstVaapiEncSlice *slice; - guint width_in_mbs, height_in_mbs; guint slice_of_mbs, slice_mod_mbs, cur_slice_mbs; - guint total_mbs; + guint mb_size; guint last_mb_index; guint i_slice, i_ref; g_assert (picture); - width_in_mbs = (GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16; - height_in_mbs = (GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16; - total_mbs = width_in_mbs * height_in_mbs; + mb_size = encoder->mb_width * encoder->mb_height; - g_assert (encoder->slice_num && encoder->slice_num < total_mbs); - slice_of_mbs = total_mbs / encoder->slice_num; - slice_mod_mbs = total_mbs % encoder->slice_num; + g_assert (encoder->num_slices && encoder->num_slices < mb_size); + slice_of_mbs = mb_size / encoder->num_slices; + slice_mod_mbs = mb_size % encoder->num_slices; last_mb_index = 0; - for (i_slice = 0; i_slice < encoder->slice_num; ++i_slice) { + for (i_slice = 0; i_slice < encoder->num_slices; ++i_slice) { cur_slice_mbs = slice_of_mbs; if (slice_mod_mbs) { ++cur_slice_mbs; @@ -1030,7 +1033,7 @@ fill_va_slices_param (GstVaapiEncoderH264 * encoder, slice_param->macroblock_address = last_mb_index; slice_param->num_macroblocks = cur_slice_mbs; slice_param->macroblock_info = VA_INVALID_ID; - slice_param->slice_type = _get_va_slice_type (picture->type); + slice_param->slice_type = h264_get_slice_type (picture->type); g_assert (slice_param->slice_type != -1); slice_param->pic_parameter_set_id = 0; slice_param->idr_pic_id = encoder->idr_num; @@ -1038,10 +1041,10 @@ fill_va_slices_param (GstVaapiEncoderH264 * encoder, /* not used if pic_order_cnt_type = 0 */ slice_param->delta_pic_order_cnt_bottom = 0; - memset (slice_param->delta_pic_order_cnt, - 0, sizeof (slice_param->delta_pic_order_cnt)); + memset (slice_param->delta_pic_order_cnt, 0, + sizeof (slice_param->delta_pic_order_cnt)); - /*only works for B frames */ + /* only works for B frames */ slice_param->direct_spatial_mv_pred_flag = FALSE; /* default equal to picture parameters */ slice_param->num_ref_idx_active_override_flag = FALSE; @@ -1064,10 +1067,7 @@ fill_va_slices_param (GstVaapiEncoderH264 * encoder, } g_assert (i_ref == 1); } - for (; - i_ref < - sizeof (slice_param->RefPicList0) / - sizeof (slice_param->RefPicList0[0]); ++i_ref) { + for (; i_ref < G_N_ELEMENTS (slice_param->RefPicList0); ++i_ref) { slice_param->RefPicList0[i_ref].picture_id = VA_INVALID_SURFACE; } @@ -1079,10 +1079,7 @@ fill_va_slices_param (GstVaapiEncoderH264 * encoder, } g_assert (i_ref == 1); } - for (; - i_ref < - sizeof (slice_param->RefPicList1) / - sizeof (slice_param->RefPicList1[0]); ++i_ref) { + for (; i_ref < G_N_ELEMENTS (slice_param->RefPicList1); ++i_ref) { slice_param->RefPicList1[i_ref].picture_id = VA_INVALID_SURFACE; } @@ -1122,10 +1119,9 @@ fill_va_slices_param (GstVaapiEncoderH264 * encoder, last_mb_index += cur_slice_mbs; gst_vaapi_enc_picture_add_slice (picture, slice); - gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & slice, NULL); - + gst_vaapi_codec_object_replace (&slice, NULL); } - g_assert (last_mb_index == total_mbs); + g_assert (last_mb_index == mb_size); return TRUE; } @@ -1147,11 +1143,11 @@ ensure_sequence (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture) !add_sequence_packed_header (encoder, picture, sequence)) goto error; gst_vaapi_enc_picture_set_sequence (picture, sequence); - gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) (&sequence), NULL); + gst_vaapi_codec_object_replace (&sequence, NULL); return TRUE; error: - gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) (&sequence), NULL); + gst_vaapi_codec_object_replace (&sequence, NULL); return FALSE; } @@ -1190,7 +1186,7 @@ ensure_slices (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture) return FALSE; } - g_assert (reflist_0_count + reflist_1_count <= encoder->max_ref_num); + g_assert (reflist_0_count + reflist_1_count <= encoder->max_ref_frames); if (reflist_0_count > encoder->max_reflist0_count) reflist_0_count = encoder->max_reflist0_count; if (reflist_1_count > encoder->max_reflist1_count) @@ -1225,7 +1221,7 @@ ensure_misc (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture) hrd->initial_buffer_fullness = 0; hrd->buffer_size = 0; } - gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & misc, NULL); + gst_vaapi_codec_object_replace (&misc, NULL); /* add ratecontrol */ if (GST_VAAPI_ENCODER_RATE_CONTROL (encoder) == GST_VAAPI_RATECONTROL_CBR || @@ -1246,7 +1242,7 @@ ensure_misc (GstVaapiEncoderH264 * encoder, GstVaapiEncPicture * picture) rate_control->initial_qp = encoder->init_qp; rate_control->min_qp = encoder->min_qp; rate_control->basic_unit_size = 0; - gst_vaapi_mini_object_replace ((GstVaapiMiniObject **) & misc, NULL); + gst_vaapi_codec_object_replace (&misc, NULL); } return TRUE; @@ -1289,7 +1285,7 @@ static void reset_properties (GstVaapiEncoderH264 * encoder) { GstVaapiEncoder *const base_encoder = GST_VAAPI_ENCODER_CAST (encoder); - guint width_mbs, height_mbs, total_mbs; + guint mb_size; if (encoder->idr_period < base_encoder->keyframe_period) encoder->idr_period = base_encoder->keyframe_period; @@ -1301,28 +1297,26 @@ reset_properties (GstVaapiEncoderH264 * encoder) encoder->min_qp < encoder->init_qp)) encoder->min_qp = encoder->init_qp; - width_mbs = (GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16; - height_mbs = (GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16; - total_mbs = width_mbs * height_mbs; + mb_size = encoder->mb_width * encoder->mb_height; + if (encoder->num_slices > (mb_size + 1) / 2) + encoder->num_slices = (mb_size + 1) / 2; + g_assert (encoder->num_slices); - if (encoder->slice_num > (total_mbs + 1) / 2) - encoder->slice_num = (total_mbs + 1) / 2; - g_assert (encoder->slice_num); + if (encoder->num_bframes > (base_encoder->keyframe_period + 1) / 2) + encoder->num_bframes = (base_encoder->keyframe_period + 1) / 2; - if (encoder->b_frame_num > (base_encoder->keyframe_period + 1) / 2) - encoder->b_frame_num = (base_encoder->keyframe_period + 1) / 2; + if (encoder->num_bframes > 50) + encoder->num_bframes = 50; - if (encoder->b_frame_num > 50) - encoder->b_frame_num = 50; - - if (encoder->b_frame_num) + if (encoder->num_bframes) encoder->cts_offset = GST_SECOND * GST_VAAPI_ENCODER_FPS_D (encoder) / GST_VAAPI_ENCODER_FPS_N (encoder); else encoder->cts_offset = 0; /* init max_frame_num, max_poc */ - encoder->log2_max_frame_num = _get_log2_max_frame_num (encoder->idr_period); + encoder->log2_max_frame_num = + h264_get_log2_max_frame_num (encoder->idr_period); g_assert (encoder->log2_max_frame_num >= 4); encoder->max_frame_num = (1 << encoder->log2_max_frame_num); encoder->log2_max_pic_order_cnt = encoder->log2_max_frame_num + 1; @@ -1331,24 +1325,21 @@ reset_properties (GstVaapiEncoderH264 * encoder) encoder->frame_index = 0; encoder->idr_num = 0; encoder->max_reflist0_count = 1; - if (encoder->b_frame_num) - encoder->max_reflist1_count = 1; - else - encoder->max_reflist1_count = 0; - encoder->max_ref_num = + encoder->max_reflist1_count = encoder->num_bframes > 0; + encoder->max_ref_frames = encoder->max_reflist0_count + encoder->max_reflist1_count; } - static GstVaapiEncoderStatus -gst_vaapi_encoder_h264_encode (GstVaapiEncoder * base, +gst_vaapi_encoder_h264_encode (GstVaapiEncoder * base_encoder, GstVaapiEncPicture * picture, GstVaapiCodedBufferProxy * codedbuf) { - GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST (base); + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264_CAST (base_encoder); GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_ERROR_UNKNOWN; GstVaapiSurfaceProxy *reconstruct = NULL; - reconstruct = gst_vaapi_encoder_create_surface (base); + reconstruct = gst_vaapi_encoder_create_surface (base_encoder); g_assert (GST_VAAPI_SURFACE_PROXY_SURFACE (reconstruct)); @@ -1375,17 +1366,17 @@ error: } static GstVaapiEncoderStatus -gst_vaapi_encoder_h264_flush (GstVaapiEncoder * base) +gst_vaapi_encoder_h264_flush (GstVaapiEncoder * base_encoder) { - GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST (base); + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264_CAST (base_encoder); GstVaapiEncPicture *pic; encoder->frame_index = 0; encoder->cur_frame_num = 0; encoder->cur_present_index = 0; while (!g_queue_is_empty (&encoder->reorder_frame_list)) { - pic = - (GstVaapiEncPicture *) g_queue_pop_head (&encoder->reorder_frame_list); + pic = g_queue_pop_head (&encoder->reorder_frame_list); gst_vaapi_enc_picture_unref (pic); } g_queue_clear (&encoder->reorder_frame_list); @@ -1468,10 +1459,11 @@ end: } static GstVaapiEncoderStatus -gst_vaapi_encoder_h264_get_codec_data (GstVaapiEncoder * base, +gst_vaapi_encoder_h264_get_codec_data (GstVaapiEncoder * base_encoder, GstBuffer ** buffer) { - GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST (base); + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264_CAST (base_encoder); *buffer = NULL; @@ -1482,10 +1474,11 @@ gst_vaapi_encoder_h264_get_codec_data (GstVaapiEncoder * base, } static GstVaapiEncoderStatus -gst_vaapi_encoder_h264_reordering (GstVaapiEncoder * base, +gst_vaapi_encoder_h264_reordering (GstVaapiEncoder * base_encoder, GstVideoCodecFrame * frame, GstVaapiEncPicture ** output) { - GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264 (base); + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264_CAST (base_encoder); GstVaapiEncPicture *picture; gboolean is_idr = FALSE; @@ -1497,7 +1490,7 @@ gst_vaapi_encoder_h264_reordering (GstVaapiEncoder * base, /* reorder_state = GST_VAAPI_ENC_H264_REORD_DUMP_FRAMES dump B frames from queue, sometime, there may also have P frame or I frame */ - g_assert (encoder->b_frame_num > 0); + g_assert (encoder->num_bframes > 0); g_return_val_if_fail (!g_queue_is_empty (&encoder->reorder_frame_list), GST_VAAPI_ENCODER_STATUS_ERROR_UNKNOWN); picture = g_queue_pop_head (&encoder->reorder_frame_list); @@ -1530,7 +1523,7 @@ gst_vaapi_encoder_h264_reordering (GstVaapiEncoder * base, ++encoder->frame_index; /* b frame enabled, check queue of reorder_frame_list */ - if (encoder->b_frame_num + if (encoder->num_bframes && !g_queue_is_empty (&encoder->reorder_frame_list)) { GstVaapiEncPicture *p_pic; @@ -1546,7 +1539,7 @@ gst_vaapi_encoder_h264_reordering (GstVaapiEncoder * base, } else { /* no b frames in queue */ _set_key_frame (picture, encoder, is_idr); g_assert (g_queue_is_empty (&encoder->reorder_frame_list)); - if (encoder->b_frame_num) + if (encoder->num_bframes) encoder->reorder_state = GST_VAAPI_ENC_H264_REORD_WAIT_FRAMES; } goto end; @@ -1556,7 +1549,7 @@ gst_vaapi_encoder_h264_reordering (GstVaapiEncoder * base, ++encoder->frame_index; if (encoder->reorder_state == GST_VAAPI_ENC_H264_REORD_WAIT_FRAMES && g_queue_get_length (&encoder->reorder_frame_list) < - encoder->b_frame_num) { + encoder->num_bframes) { g_queue_push_tail (&encoder->reorder_frame_list, picture); return GST_VAAPI_ENCODER_STATUS_NO_SURFACE; } @@ -1584,7 +1577,8 @@ end: static void set_context_info (GstVaapiEncoder * base_encoder) { - GstVaapiEncoderH264 *const encoder = GST_VAAPI_ENCODER_H264 (base_encoder); + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264_CAST (base_encoder); GstVideoInfo *const vip = GST_VAAPI_ENCODER_VIDEO_INFO (encoder); const guint DEFAULT_SURFACES_COUNT = 3; @@ -1600,7 +1594,7 @@ set_context_info (GstVaapiEncoder * base_encoder) base_encoder->profile = encoder->profile; base_encoder->num_ref_frames = - (encoder->b_frame_num ? 2 : 1) + DEFAULT_SURFACES_COUNT; + (encoder->num_bframes ? 2 : 1) + DEFAULT_SURFACES_COUNT; /* Only YUV 4:2:0 formats are supported for now. This means that we have a limit of 3200 bits per macroblock. */ @@ -1628,6 +1622,9 @@ gst_vaapi_encoder_h264_reconfigure (GstVaapiEncoder * base_encoder) GstVaapiEncoderH264 *const encoder = GST_VAAPI_ENCODER_H264_CAST (base_encoder); + encoder->mb_width = (GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16; + encoder->mb_height = (GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16; + if (!ensure_profile_and_level (encoder)) goto error; if (!ensure_bitrate (encoder)) @@ -1642,49 +1639,30 @@ error: } static gboolean -gst_vaapi_encoder_h264_init (GstVaapiEncoder * base) +gst_vaapi_encoder_h264_init (GstVaapiEncoder * base_encoder) { - GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264 (base); + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264_CAST (base_encoder); - /* init attributes */ - encoder->profile = 0; - encoder->level = 0; - encoder->idr_period = 0; - //gst_vaapi_base_encoder_set_frame_notify(GST_VAAPI_BASE_ENCODER(encoder), TRUE); - - /* init private values */ - encoder->is_avc = FALSE; /* re-ordering */ g_queue_init (&encoder->reorder_frame_list); encoder->reorder_state = GST_VAAPI_ENC_H264_REORD_NONE; - encoder->frame_index = 0; - encoder->cur_frame_num = 0; - encoder->cur_present_index = 0; + /* reference frames */ g_queue_init (&encoder->ref_list); - encoder->max_ref_num = 0; + encoder->max_ref_frames = 0; encoder->max_reflist0_count = 1; encoder->max_reflist1_count = 1; - encoder->sps_data = NULL; - encoder->pps_data = NULL; - - encoder->cts_offset = 0; - - encoder->max_frame_num = 0; - encoder->log2_max_frame_num = 0; - encoder->max_pic_order_cnt = 0; - encoder->log2_max_pic_order_cnt = 0; - encoder->idr_num = 0; - return TRUE; } static void -gst_vaapi_encoder_h264_finalize (GstVaapiEncoder * base) +gst_vaapi_encoder_h264_finalize (GstVaapiEncoder * base_encoder) { /*free private buffers */ - GstVaapiEncoderH264 *const encoder = GST_VAAPI_ENCODER_H264 (base); + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264_CAST (base_encoder); GstVaapiEncPicture *pic; GstVaapiEncoderH264Ref *ref; @@ -1692,14 +1670,13 @@ gst_vaapi_encoder_h264_finalize (GstVaapiEncoder * base) gst_buffer_replace (&encoder->pps_data, NULL); while (!g_queue_is_empty (&encoder->ref_list)) { - ref = (GstVaapiEncoderH264Ref *) g_queue_pop_head (&encoder->ref_list); + ref = g_queue_pop_head (&encoder->ref_list); reference_pic_free (encoder, ref); } g_queue_clear (&encoder->ref_list); while (!g_queue_is_empty (&encoder->reorder_frame_list)) { - pic = - (GstVaapiEncPicture *) g_queue_pop_head (&encoder->reorder_frame_list); + pic = g_queue_pop_head (&encoder->reorder_frame_list); gst_vaapi_enc_picture_unref (pic); } g_queue_clear (&encoder->reorder_frame_list); @@ -1710,11 +1687,12 @@ static GstVaapiEncoderStatus gst_vaapi_encoder_h264_set_property (GstVaapiEncoder * base_encoder, gint prop_id, const GValue * value) { - GstVaapiEncoderH264 *const encoder = GST_VAAPI_ENCODER_H264 (base_encoder); + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264_CAST (base_encoder); switch (prop_id) { case GST_VAAPI_ENCODER_H264_PROP_MAX_BFRAMES: - encoder->b_frame_num = g_value_get_uint (value); + encoder->num_bframes = g_value_get_uint (value); break; case GST_VAAPI_ENCODER_H264_PROP_INIT_QP: encoder->init_qp = g_value_get_uint (value); @@ -1723,7 +1701,7 @@ gst_vaapi_encoder_h264_set_property (GstVaapiEncoder * base_encoder, encoder->min_qp = g_value_get_uint (value); break; case GST_VAAPI_ENCODER_H264_PROP_NUM_SLICES: - encoder->slice_num = g_value_get_uint (value); + encoder->num_slices = g_value_get_uint (value); break; default: return GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_PARAMETER; @@ -1744,6 +1722,15 @@ gst_vaapi_encoder_h264_class (void) return &GstVaapiEncoderH264Class; } +/** + * gst_vaapi_encoder_h264_new: + * @display: a #GstVaapiDisplay + * + * Creates a new #GstVaapiEncoder for H.264 encoding. Note that the + * only supported output stream format is "byte-stream" format. + * + * Return value: the newly allocated #GstVaapiEncoder object + */ GstVaapiEncoder * gst_vaapi_encoder_h264_new (GstVaapiDisplay * display) { diff --git a/gst-libs/gst/vaapi/gstvaapiencoder_h264.h b/gst-libs/gst/vaapi/gstvaapiencoder_h264.h index 9b3eb4981e..0c64e0f341 100644 --- a/gst-libs/gst/vaapi/gstvaapiencoder_h264.h +++ b/gst-libs/gst/vaapi/gstvaapiencoder_h264.h @@ -26,6 +26,9 @@ G_BEGIN_DECLS +#define GST_VAAPI_ENCODER_H264(encoder) \ + ((GstVaapiEncoderH264 *) (encoder)) + typedef struct _GstVaapiEncoderH264 GstVaapiEncoderH264; /** diff --git a/gst-libs/gst/vaapi/gstvaapiencoder_h264_priv.h b/gst-libs/gst/vaapi/gstvaapiencoder_h264_priv.h index f2b3a8e316..6d8ef763d4 100644 --- a/gst-libs/gst/vaapi/gstvaapiencoder_h264_priv.h +++ b/gst-libs/gst/vaapi/gstvaapiencoder_h264_priv.h @@ -22,15 +22,10 @@ #ifndef GST_VAAPI_ENCODER_H264_PRIV_H #define GST_VAAPI_ENCODER_H264_PRIV_H -#include -#include -#include -#include +#include "gstvaapiencoder_priv.h" G_BEGIN_DECLS -#define GST_VAAPI_ENCODER_H264(encoder) \ - ((GstVaapiEncoderH264 *)(encoder)) #define GST_VAAPI_ENCODER_H264_CAST(encoder) \ ((GstVaapiEncoderH264 *)(encoder)) @@ -55,26 +50,22 @@ typedef enum #define GST_VAAPI_ENCODER_H264_DEFAULT_PROFILE GST_VAAPI_PROFILE_H264_BASELINE #define GST_VAAPI_ENCODER_H264_DEFAULT_LEVEL GST_VAAPI_ENCODER_H264_LEVEL_31 -#define GST_VAAPI_ENCODER_H264_DEFAULT_INIT_QP 26 -#define GST_VAAPI_ENCODER_H264_DEFAULT_MIN_QP 1 #define GST_VAAPI_ENCODER_H264_MAX_IDR_PERIOD 512 -#define GST_VAAPI_ENCODER_H264_DEFAULT_SLICE_NUM 1 - struct _GstVaapiEncoderH264 { - GstVaapiEncoder parent; + GstVaapiEncoder parent_instance; - /* public */ - guint32 profile; - guint32 level; + GstVaapiProfile profile; + guint32 level_idc; guint32 idr_period; - guint32 init_qp; /*default 24 */ - guint32 min_qp; /*default 1 */ - guint32 slice_num; - guint32 b_frame_num; + guint32 init_qp; + guint32 min_qp; + guint32 num_slices; + guint32 num_bframes; + guint32 mb_width; + guint32 mb_height; - /* private */ gboolean is_avc; /* avc or bytestream */ /* re-ordering */ GQueue reorder_frame_list; @@ -86,7 +77,7 @@ struct _GstVaapiEncoderH264 /* reference list */ GQueue ref_list; - guint max_ref_num; + guint max_ref_frames; /* max reflist count */ guint max_reflist0_count; guint max_reflist1_count; @@ -104,4 +95,4 @@ struct _GstVaapiEncoderH264 G_END_DECLS -#endif /*GST_VAAPI_ENCODER_H264_PRIV_H */ +#endif /* GST_VAAPI_ENCODER_H264_PRIV_H */ diff --git a/gst/vaapi/gstvaapiencode_h264.c b/gst/vaapi/gstvaapiencode_h264.c index 3e525d30e9..f16620b6d9 100644 --- a/gst/vaapi/gstvaapiencode_h264.c +++ b/gst/vaapi/gstvaapiencode_h264.c @@ -261,8 +261,8 @@ gst_vaapiencode_h264_alloc_buffer (GstVaapiEncode * base_encode, GstVaapiCodedBuffer * coded_buf, GstBuffer ** out_buffer_ptr) { GstVaapiEncodeH264 *const encode = GST_VAAPIENCODE_H264_CAST (base_encode); - GstVaapiEncoderH264 *const encoder = (GstVaapiEncoderH264 *) - base_encode->encoder; + GstVaapiEncoderH264 *const encoder = + GST_VAAPI_ENCODER_H264 (base_encode->encoder); GstFlowReturn ret; g_return_val_if_fail (encoder != NULL, GST_FLOW_ERROR);