/*
* 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
*/
#include "sysdeps.h"
+#include <va/va.h>
+#include <va/va_enc_h264.h>
+#include <gst/base/gstbitwriter.h>
#include "gstvaapicompat.h"
#include "gstvaapiencoder_h264.h"
#include "gstvaapiencoder_h264_priv.h"
-#include "gstvaapiencoder_priv.h"
#include "gstvaapicodedbufferproxy_priv.h"
-
-#include <va/va.h>
-#include <va/va_enc_h264.h>
-
-#include "gstvaapicontext.h"
#include "gstvaapisurface.h"
-#include "gstvaapidisplay_priv.h"
#define DEBUG 1
#include "gstvaapidebug.h"
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:
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;
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);
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
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;
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;
/* 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 */
}
/* 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);
}
/* 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);
}
}
/* 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);
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);
}
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;
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;
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;
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;
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);
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;
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;
}
GstVaapiEncSequence * sequence)
{
GstVaapiEncoder *const base_encoder = GST_VAAPI_ENCODER_CAST (encoder);
- VAEncSequenceParameterBufferH264 *seq = sequence->param;
- guint width_in_mbs, height_in_mbs;
-
- width_in_mbs = (GST_VAAPI_ENCODER_WIDTH (encoder) + 15) / 16;
- height_in_mbs = (GST_VAAPI_ENCODER_HEIGHT (encoder) + 15) / 16;
+ VAEncSequenceParameterBufferH264 *const seq_param = sequence->param;
- 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;
}
}
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);
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->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->coded_buf = GST_VAAPI_OBJECT_ID (codedbuf);
+
+ 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;
}
{
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;
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;
/* 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;
}
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;
}
}
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;
}
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;
}
!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;
}
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)
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 ||
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;
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;
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;
-
- if (encoder->slice_num > (total_mbs + 1) / 2)
- encoder->slice_num = (total_mbs + 1) / 2;
- g_assert (encoder->slice_num);
+ 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->b_frame_num > (base_encoder->keyframe_period + 1) / 2)
- encoder->b_frame_num = (base_encoder->keyframe_period + 1) / 2;
+ if (encoder->num_bframes > (base_encoder->keyframe_period + 1) / 2)
+ encoder->num_bframes = (base_encoder->keyframe_period + 1) / 2;
- if (encoder->b_frame_num > 50)
- encoder->b_frame_num = 50;
+ if (encoder->num_bframes > 50)
+ encoder->num_bframes = 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;
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));
}
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);
}
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;
}
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;
/* 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);
++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;
} 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;
++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;
}
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;
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. */
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))
}
static gboolean
-gst_vaapi_encoder_h264_init (GstVaapiEncoder * base)
+gst_vaapi_encoder_h264_init (GstVaapiEncoder * base_encoder)
{
- GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264 (base);
-
- /* 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);
+ GstVaapiEncoderH264 *const encoder =
+ GST_VAAPI_ENCODER_H264_CAST (base_encoder);
- /* 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;
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);
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);
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;
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)
{
projects / platform / upstream / gstreamer.git / commitdiff