/* * gstvaapiencoder_vp9.c - VP9 encoder * * Copyright (C) 2016 Intel Corporation * Author: Sreerenj Balachandran * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 * of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301 USA */ #include "sysdeps.h" #include #include #include "gstvaapicompat.h" #include "gstvaapiencoder_priv.h" #include "gstvaapiencoder_vp9.h" #include "gstvaapicodedbufferproxy_priv.h" #include "gstvaapisurface.h" #define DEBUG 1 #include "gstvaapidebug.h" /* Define default rate control mode ("constant-qp") */ #define DEFAULT_RATECONTROL GST_VAAPI_RATECONTROL_CQP /* Supported set of VA rate controls, within this implementation */ #define SUPPORTED_RATECONTROLS \ (GST_VAAPI_RATECONTROL_MASK (CQP) | \ GST_VAAPI_RATECONTROL_MASK (CBR) | \ GST_VAAPI_RATECONTROL_MASK (VBR)) /* Supported set of tuning options, within this implementation */ #define SUPPORTED_TUNE_OPTIONS \ (GST_VAAPI_ENCODER_TUNE_MASK (NONE) | \ GST_VAAPI_ENCODER_TUNE_MASK (LOW_POWER)) /* Supported set of VA packed headers, within this implementation */ #define SUPPORTED_PACKED_HEADERS \ (VA_ENC_PACKED_HEADER_NONE) #define DEFAULT_LOOP_FILTER_LEVEL 10 #define DEFAULT_SHARPNESS_LEVEL 0 #define DEFAULT_YAC_QINDEX 60 #define MAX_FRAME_WIDTH 4096 #define MAX_FRAME_HEIGHT 4096 /* Default CPB length (in milliseconds) */ #define DEFAULT_CPB_LENGTH 1500 typedef enum { GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_0 = 0, GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_1 = 1 } GstVaapiEnoderVP9RefPicMode; static GType gst_vaapi_encoder_vp9_ref_pic_mode_type (void) { static GType gtype = 0; if (gtype == 0) { static const GEnumValue values[] = { {GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_0, "Use Keyframe(Alt & Gold) and Previousframe(Last) for prediction ", "mode-0"}, {GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_1, "Use last three frames for prediction (n:Last n-1:Gold n-2:Alt)", "mode-1"}, {0, NULL, NULL}, }; gtype = g_enum_register_static ("GstVaapiEncoderVP9RefPicMode", values); } return gtype; } /* ------------------------------------------------------------------------- */ /* --- VP9 Encoder --- */ /* ------------------------------------------------------------------------- */ struct _GstVaapiEncoderVP9 { GstVaapiEncoder parent_instance; GstVaapiProfile profile; guint loop_filter_level; guint sharpness_level; guint yac_qi; guint ref_pic_mode; guint frame_num; GstVaapiSurfaceProxy *ref_list[GST_VP9_REF_FRAMES]; /* reference list */ guint ref_list_idx; /* next free slot in ref_list */ GstVaapiEntrypoint entrypoint; /* Bitrate contral parameters, CPB = Coded Picture Buffer */ guint bitrate_bits; /* bitrate (bits) */ guint cpb_length; /* length of CPB buffer (ms) */ }; /* Estimates a good enough bitrate if none was supplied */ static void ensure_bitrate (GstVaapiEncoderVP9 * encoder) { GstVaapiEncoder *const base_encoder = GST_VAAPI_ENCODER_CAST (encoder); guint bitrate; switch (GST_VAAPI_ENCODER_RATE_CONTROL (encoder)) { case GST_VAAPI_RATECONTROL_CBR: case GST_VAAPI_RATECONTROL_VBR: if (!base_encoder->bitrate) { /* FIXME: Provide better estimation */ /* Using a 1/6 compression ratio */ /* 12 bits per pixel fro yuv420 */ base_encoder->bitrate = (GST_VAAPI_ENCODER_WIDTH (encoder) * GST_VAAPI_ENCODER_HEIGHT (encoder) * 12 / 6) * GST_VAAPI_ENCODER_FPS_N (encoder) / GST_VAAPI_ENCODER_FPS_D (encoder) / 1000; GST_INFO ("target bitrate computed to %u kbps", base_encoder->bitrate); } bitrate = (base_encoder->bitrate * 1000); if (bitrate != encoder->bitrate_bits) { GST_DEBUG ("HRD bitrate: %u bits/sec", bitrate); encoder->bitrate_bits = bitrate; } break; default: base_encoder->bitrate = 0; break; } } /* Derives the profile that suits best to the configuration */ static GstVaapiEncoderStatus ensure_profile (GstVaapiEncoderVP9 * encoder) { /* Profile Color | Depth Chroma | Subsampling 0 | 8 bit/sample | 4:2:0 1 | 8 bit | 4:2:2, 4:4:4 2 | 10 or 12 bit | 4:2:0 3 | 10 or 12 bit | 4:2:2, 4:4:4 */ const GstVideoFormat format = GST_VIDEO_INFO_FORMAT (GST_VAAPI_ENCODER_VIDEO_INFO (encoder)); if (format == GST_VIDEO_FORMAT_P010_10LE) encoder->profile = GST_VAAPI_PROFILE_VP9_2; else encoder->profile = GST_VAAPI_PROFILE_VP9_0; /* Ensure bitrate if not set already */ ensure_bitrate (encoder); return GST_VAAPI_ENCODER_STATUS_SUCCESS; } /* Derives the profile supported by the underlying hardware */ static gboolean ensure_hw_profile (GstVaapiEncoderVP9 * encoder) { GstVaapiDisplay *const display = GST_VAAPI_ENCODER_DISPLAY (encoder); GstVaapiEntrypoint entrypoint = encoder->entrypoint; GstVaapiProfile profile, profiles[2]; guint i, num_profiles = 0; profiles[num_profiles++] = encoder->profile; profile = GST_VAAPI_PROFILE_UNKNOWN; for (i = 0; i < num_profiles; i++) { if (gst_vaapi_display_has_encoder (display, profiles[i], entrypoint)) { profile = profiles[i]; break; } } if (profile == GST_VAAPI_PROFILE_UNKNOWN) goto error_unsupported_profile; GST_VAAPI_ENCODER_CAST (encoder)->profile = profile; return TRUE; /* ERRORS */ error_unsupported_profile: { GST_ERROR ("unsupported HW profile %s", gst_vaapi_profile_get_va_name (encoder->profile)); return FALSE; } } static GstVaapiEncoderStatus set_context_info (GstVaapiEncoder * base_encoder) { GstVaapiEncoderVP9 *encoder = GST_VAAPI_ENCODER_VP9 (base_encoder); GstVideoInfo *const vip = GST_VAAPI_ENCODER_VIDEO_INFO (encoder); const guint DEFAULT_SURFACES_COUNT = 2; /* FIXME: Maximum sizes for common headers (in bytes) */ if (!ensure_hw_profile (encoder)) return GST_VAAPI_ENCODER_STATUS_ERROR_UNSUPPORTED_PROFILE; base_encoder->num_ref_frames = 3 + DEFAULT_SURFACES_COUNT; /* Only YUV 4:2:0 formats are supported for now. */ base_encoder->codedbuf_size = GST_ROUND_UP_16 (vip->width) * GST_ROUND_UP_16 (vip->height) * 3 / 2; base_encoder->context_info.entrypoint = encoder->entrypoint; return GST_VAAPI_ENCODER_STATUS_SUCCESS; } static gboolean fill_sequence (GstVaapiEncoderVP9 * encoder, GstVaapiEncSequence * sequence) { GstVaapiEncoder *const base_encoder = GST_VAAPI_ENCODER_CAST (encoder); VAEncSequenceParameterBufferVP9 *const seq_param = sequence->param; memset (seq_param, 0, sizeof (VAEncSequenceParameterBufferVP9)); seq_param->max_frame_width = MAX_FRAME_WIDTH; seq_param->max_frame_height = MAX_FRAME_HEIGHT; /* keyframe minimum interval */ seq_param->kf_min_dist = 1; /* keyframe maximum interval */ seq_param->kf_max_dist = base_encoder->keyframe_period; seq_param->intra_period = base_encoder->keyframe_period; seq_param->bits_per_second = encoder->bitrate_bits; return TRUE; } static gboolean ensure_sequence (GstVaapiEncoderVP9 * encoder, GstVaapiEncPicture * picture) { GstVaapiEncSequence *sequence; g_assert (picture); if (picture->type != GST_VAAPI_PICTURE_TYPE_I) return TRUE; sequence = GST_VAAPI_ENC_SEQUENCE_NEW (VP9, encoder); if (!sequence) goto error; if (!fill_sequence (encoder, sequence)) goto error; gst_vaapi_enc_picture_set_sequence (picture, sequence); gst_vaapi_codec_object_replace (&sequence, NULL); return TRUE; /* ERRORS */ error: { gst_vaapi_codec_object_replace (&sequence, NULL); return FALSE; } } static gboolean ensure_control_rate_params (GstVaapiEncoderVP9 * encoder) { if (GST_VAAPI_ENCODER_RATE_CONTROL (encoder) == GST_VAAPI_RATECONTROL_CQP) return TRUE; /* RateControl params */ GST_VAAPI_ENCODER_VA_RATE_CONTROL (encoder).bits_per_second = encoder->bitrate_bits; GST_VAAPI_ENCODER_VA_RATE_CONTROL (encoder).window_size = encoder->cpb_length; /* *INDENT-OFF* */ /* HRD params */ GST_VAAPI_ENCODER_VA_HRD (encoder) = (VAEncMiscParameterHRD) { .buffer_size = encoder->bitrate_bits * 2, .initial_buffer_fullness = encoder->bitrate_bits, }; /* *INDENT-ON* */ return TRUE; } static gboolean ensure_misc_params (GstVaapiEncoderVP9 * encoder, GstVaapiEncPicture * picture) { GstVaapiEncoder *const base_encoder = GST_VAAPI_ENCODER_CAST (encoder); if (!gst_vaapi_encoder_ensure_param_quality_level (base_encoder, picture)) return FALSE; if (!gst_vaapi_encoder_ensure_param_control_rate (base_encoder, picture)) return FALSE; return TRUE; } static void get_ref_indices (guint ref_pic_mode, guint ref_list_idx, guint * last_idx, guint * gf_idx, guint * arf_idx, guint8 * refresh_frame_flags) { if (ref_pic_mode == GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_0) { *last_idx = ref_list_idx - 1; *gf_idx = 1; *arf_idx = 2; *refresh_frame_flags = 0x01; } else if (ref_pic_mode == GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_1) { gint last_filled_idx = (ref_list_idx - 1) & (GST_VP9_REF_FRAMES - 1); *last_idx = last_filled_idx; *gf_idx = (last_filled_idx - 1) & (GST_VP9_REF_FRAMES - 1); *arf_idx = (last_filled_idx - 2) & (GST_VP9_REF_FRAMES - 1); *refresh_frame_flags = 1 << ((*last_idx + 1) % GST_VP9_REF_FRAMES); } GST_LOG ("last_ref_idx:%d gold_ref_idx:%d alt_reff_idx:%d refesh_frame_flag:%x", *last_idx, *gf_idx, *arf_idx, *refresh_frame_flags); } static gboolean fill_picture (GstVaapiEncoderVP9 * encoder, GstVaapiEncPicture * picture, GstVaapiCodedBuffer * codedbuf, GstVaapiSurfaceProxy * surface) { VAEncPictureParameterBufferVP9 *const pic_param = picture->param; guint i, last_idx = 0, gf_idx = 0, arf_idx = 0; guint8 refresh_frame_flags = 0; memset (pic_param, 0, sizeof (VAEncPictureParameterBufferVP9)); pic_param->reconstructed_frame = GST_VAAPI_SURFACE_PROXY_SURFACE_ID (surface); pic_param->coded_buf = GST_VAAPI_OBJECT_ID (codedbuf); /* Update Reference Frame list */ if (picture->type == GST_VAAPI_PICTURE_TYPE_I) memset (pic_param->reference_frames, 0xFF, sizeof (pic_param->reference_frames)); else { for (i = 0; i < G_N_ELEMENTS (pic_param->reference_frames); i++) { pic_param->reference_frames[i] = GST_VAAPI_SURFACE_PROXY_SURFACE_ID (encoder->ref_list[i]); } } /* It is possible to have dynamic scaling with gpu by providing * src and destination resoltuion. For now we are just using * default encoder width and height */ pic_param->frame_width_src = GST_VAAPI_ENCODER_WIDTH (encoder); pic_param->frame_height_src = GST_VAAPI_ENCODER_HEIGHT (encoder); pic_param->frame_width_dst = GST_VAAPI_ENCODER_WIDTH (encoder); pic_param->frame_height_dst = GST_VAAPI_ENCODER_HEIGHT (encoder); pic_param->pic_flags.bits.show_frame = 1; if (picture->type == GST_VAAPI_PICTURE_TYPE_P) { pic_param->pic_flags.bits.frame_type = GST_VP9_INTER_FRAME; /* use three of the reference frames (last, golden and altref) * for prediction */ pic_param->ref_flags.bits.ref_frame_ctrl_l0 = 0x7; get_ref_indices (encoder->ref_pic_mode, encoder->ref_list_idx, &last_idx, &gf_idx, &arf_idx, &refresh_frame_flags); pic_param->ref_flags.bits.ref_last_idx = last_idx; pic_param->ref_flags.bits.ref_gf_idx = gf_idx; pic_param->ref_flags.bits.ref_arf_idx = arf_idx; pic_param->refresh_frame_flags = refresh_frame_flags; } pic_param->luma_ac_qindex = encoder->yac_qi; pic_param->luma_dc_qindex_delta = 1; pic_param->chroma_ac_qindex_delta = 1; pic_param->chroma_dc_qindex_delta = 1; pic_param->filter_level = encoder->loop_filter_level; pic_param->sharpness_level = encoder->sharpness_level; return TRUE; } static gboolean ensure_picture (GstVaapiEncoderVP9 * encoder, GstVaapiEncPicture * picture, GstVaapiCodedBufferProxy * codedbuf_proxy, GstVaapiSurfaceProxy * surface) { GstVaapiCodedBuffer *const codedbuf = GST_VAAPI_CODED_BUFFER_PROXY_BUFFER (codedbuf_proxy); if (!fill_picture (encoder, picture, codedbuf, surface)) return FALSE; return TRUE; } static void update_ref_list (GstVaapiEncoderVP9 * encoder, GstVaapiEncPicture * picture, GstVaapiSurfaceProxy * ref) { guint i; if (picture->type == GST_VAAPI_PICTURE_TYPE_I) { for (i = 0; i < G_N_ELEMENTS (encoder->ref_list); i++) gst_vaapi_surface_proxy_replace (&encoder->ref_list[i], ref); gst_vaapi_surface_proxy_unref (ref); /* set next free slot index */ encoder->ref_list_idx = 1; return; } switch (encoder->ref_pic_mode) { case GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_0: gst_vaapi_surface_proxy_replace (&encoder->ref_list[0], ref); gst_vaapi_surface_proxy_unref (ref); break; case GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_1: gst_vaapi_surface_proxy_replace (&encoder->ref_list[encoder-> ref_list_idx], ref); gst_vaapi_surface_proxy_unref (ref); encoder->ref_list_idx = (encoder->ref_list_idx + 1) % GST_VP9_REF_FRAMES; break; default: g_assert ("Code shouldn't reach here"); break; } } static GstVaapiEncoderStatus gst_vaapi_encoder_vp9_encode (GstVaapiEncoder * base_encoder, GstVaapiEncPicture * picture, GstVaapiCodedBufferProxy * codedbuf) { GstVaapiEncoderVP9 *const encoder = GST_VAAPI_ENCODER_VP9 (base_encoder); GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_ERROR_UNKNOWN; GstVaapiSurfaceProxy *reconstruct = NULL; reconstruct = gst_vaapi_encoder_create_surface (base_encoder); g_assert (GST_VAAPI_SURFACE_PROXY_SURFACE (reconstruct)); if (!ensure_sequence (encoder, picture)) goto error; if (!ensure_misc_params (encoder, picture)) goto error; if (!ensure_picture (encoder, picture, codedbuf, reconstruct)) goto error; if (!gst_vaapi_enc_picture_encode (picture)) goto error; update_ref_list (encoder, picture, reconstruct); return GST_VAAPI_ENCODER_STATUS_SUCCESS; /* ERRORS */ error: { if (reconstruct) gst_vaapi_encoder_release_surface (GST_VAAPI_ENCODER (encoder), reconstruct); return ret; } } static GstVaapiEncoderStatus gst_vaapi_encoder_vp9_flush (GstVaapiEncoder * base_encoder) { GstVaapiEncoderVP9 *const encoder = GST_VAAPI_ENCODER_VP9 (base_encoder); encoder->frame_num = 0; return GST_VAAPI_ENCODER_STATUS_SUCCESS; } static GstVaapiEncoderStatus gst_vaapi_encoder_vp9_reordering (GstVaapiEncoder * base_encoder, GstVideoCodecFrame * frame, GstVaapiEncPicture ** output) { GstVaapiEncoderVP9 *const encoder = GST_VAAPI_ENCODER_VP9 (base_encoder); GstVaapiEncPicture *picture = NULL; GstVaapiEncoderStatus status = GST_VAAPI_ENCODER_STATUS_SUCCESS; if (!frame) return GST_VAAPI_ENCODER_STATUS_NO_SURFACE; picture = GST_VAAPI_ENC_PICTURE_NEW (VP9, encoder, frame); if (!picture) { GST_WARNING ("create VP9 picture failed, frame timestamp:%" GST_TIME_FORMAT, GST_TIME_ARGS (frame->pts)); return GST_VAAPI_ENCODER_STATUS_ERROR_ALLOCATION_FAILED; } if (encoder->frame_num >= base_encoder->keyframe_period) { encoder->frame_num = 0; } if (encoder->frame_num == 0) { picture->type = GST_VAAPI_PICTURE_TYPE_I; GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame); } else { picture->type = GST_VAAPI_PICTURE_TYPE_P; } encoder->frame_num++; *output = picture; return status; } static GstVaapiEncoderStatus gst_vaapi_encoder_vp9_reconfigure (GstVaapiEncoder * base_encoder) { GstVaapiEncoderVP9 *const encoder = GST_VAAPI_ENCODER_VP9 (base_encoder); GstVaapiEncoderStatus status; status = ensure_profile (encoder); if (status != GST_VAAPI_ENCODER_STATUS_SUCCESS) return status; if (GST_VAAPI_ENCODER_TUNE (encoder) == GST_VAAPI_ENCODER_TUNE_LOW_POWER) encoder->entrypoint = GST_VAAPI_ENTRYPOINT_SLICE_ENCODE_LP; ensure_control_rate_params (encoder); return set_context_info (base_encoder); } struct _GstVaapiEncoderVP9Class { GstVaapiEncoderClass parent_class; }; G_DEFINE_TYPE (GstVaapiEncoderVP9, gst_vaapi_encoder_vp9, GST_TYPE_VAAPI_ENCODER); static void gst_vaapi_encoder_vp9_init (GstVaapiEncoderVP9 * encoder) { encoder->frame_num = 0; encoder->loop_filter_level = DEFAULT_LOOP_FILTER_LEVEL; encoder->sharpness_level = DEFAULT_SHARPNESS_LEVEL; encoder->yac_qi = DEFAULT_YAC_QINDEX; encoder->cpb_length = DEFAULT_CPB_LENGTH; encoder->entrypoint = GST_VAAPI_ENTRYPOINT_SLICE_ENCODE; memset (encoder->ref_list, 0, G_N_ELEMENTS (encoder->ref_list) * sizeof (encoder->ref_list[0])); encoder->ref_list_idx = 0; } /** * @ENCODER_VP9_PROP_RATECONTROL: Rate control (#GstVaapiRateControl). * @ENCODER_VP9_PROP_TUNE: The tuning options (#GstVaapiEncoderTune). * @ENCODER_VP9_PROP_LOOP_FILTER_LEVEL: Loop Filter Level(uint). * @ENCODER_VP9_PROP_LOOP_SHARPNESS_LEVEL: Sharpness Level(uint). * @ENCODER_VP9_PROP_YAC_Q_INDEX: Quantization table index for luma AC * @ENCODER_VP9_PROP_REF_PIC_MODE: Reference picute selection modes * @ENCODER_VP9_PROP_CPB_LENGTH:Length of CPB buffer in milliseconds * * The set of VP9 encoder specific configurable properties. */ enum { ENCODER_VP9_PROP_RATECONTROL = 1, ENCODER_VP9_PROP_TUNE, ENCODER_VP9_PROP_LOOP_FILTER_LEVEL, ENCODER_VP9_PROP_SHARPNESS_LEVEL, ENCODER_VP9_PROP_YAC_Q_INDEX, ENCODER_VP9_PROP_REF_PIC_MODE, ENCODER_VP9_PROP_CPB_LENGTH, ENCODER_VP9_N_PROPERTIES }; static GParamSpec *properties[ENCODER_VP9_N_PROPERTIES]; static void gst_vaapi_encoder_vp9_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstVaapiEncoder *const base_encoder = GST_VAAPI_ENCODER (object); GstVaapiEncoderVP9 *const encoder = GST_VAAPI_ENCODER_VP9 (object); if (base_encoder->num_codedbuf_queued > 0) { GST_ERROR_OBJECT (object, "failed to set any property after encoding started"); return; } switch (prop_id) { case ENCODER_VP9_PROP_RATECONTROL: gst_vaapi_encoder_set_rate_control (base_encoder, g_value_get_enum (value)); break; case ENCODER_VP9_PROP_TUNE: gst_vaapi_encoder_set_tuning (base_encoder, g_value_get_enum (value)); break; case ENCODER_VP9_PROP_LOOP_FILTER_LEVEL: encoder->loop_filter_level = g_value_get_uint (value); break; case ENCODER_VP9_PROP_SHARPNESS_LEVEL: encoder->sharpness_level = g_value_get_uint (value); break; case ENCODER_VP9_PROP_YAC_Q_INDEX: encoder->yac_qi = g_value_get_uint (value); break; case ENCODER_VP9_PROP_REF_PIC_MODE: encoder->ref_pic_mode = g_value_get_enum (value); break; case ENCODER_VP9_PROP_CPB_LENGTH: encoder->cpb_length = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void gst_vaapi_encoder_vp9_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstVaapiEncoderVP9 *const encoder = GST_VAAPI_ENCODER_VP9 (object); GstVaapiEncoder *const base_encoder = GST_VAAPI_ENCODER (object); switch (prop_id) { case ENCODER_VP9_PROP_RATECONTROL: g_value_set_enum (value, base_encoder->rate_control); break; case ENCODER_VP9_PROP_TUNE: g_value_set_enum (value, base_encoder->tune); break; case ENCODER_VP9_PROP_LOOP_FILTER_LEVEL: g_value_set_uint (value, encoder->loop_filter_level); break; case ENCODER_VP9_PROP_SHARPNESS_LEVEL: g_value_set_uint (value, encoder->sharpness_level); break; case ENCODER_VP9_PROP_YAC_Q_INDEX: g_value_set_uint (value, encoder->yac_qi); break; case ENCODER_VP9_PROP_REF_PIC_MODE: g_value_set_enum (value, encoder->ref_pic_mode); break; case ENCODER_VP9_PROP_CPB_LENGTH: g_value_set_uint (value, encoder->cpb_length); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } GST_VAAPI_ENCODER_DEFINE_CLASS_DATA (VP9); static void gst_vaapi_encoder_vp9_class_init (GstVaapiEncoderVP9Class * klass) { GObjectClass *const object_class = G_OBJECT_CLASS (klass); GstVaapiEncoderClass *const encoder_class = GST_VAAPI_ENCODER_CLASS (klass); encoder_class->class_data = &g_class_data; encoder_class->reconfigure = gst_vaapi_encoder_vp9_reconfigure; encoder_class->reordering = gst_vaapi_encoder_vp9_reordering; encoder_class->encode = gst_vaapi_encoder_vp9_encode; encoder_class->flush = gst_vaapi_encoder_vp9_flush; object_class->set_property = gst_vaapi_encoder_vp9_set_property; object_class->get_property = gst_vaapi_encoder_vp9_get_property; properties[ENCODER_VP9_PROP_RATECONTROL] = g_param_spec_enum ("rate-control", "Rate Control", "Rate control mode", g_class_data.rate_control_get_type (), g_class_data.default_rate_control, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | GST_VAAPI_PARAM_ENCODER_EXPOSURE); properties[ENCODER_VP9_PROP_TUNE] = g_param_spec_enum ("tune", "Encoder Tuning", "Encoder tuning option", g_class_data.encoder_tune_get_type (), g_class_data.default_encoder_tune, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | GST_VAAPI_PARAM_ENCODER_EXPOSURE); properties[ENCODER_VP9_PROP_LOOP_FILTER_LEVEL] = g_param_spec_uint ("loop-filter-level", "Loop Filter Level", "Controls the deblocking filter strength", 0, 63, DEFAULT_LOOP_FILTER_LEVEL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | GST_VAAPI_PARAM_ENCODER_EXPOSURE); properties[ENCODER_VP9_PROP_SHARPNESS_LEVEL] = g_param_spec_uint ("sharpness-level", "Sharpness Level", "Controls the deblocking filter sensitivity", 0, 7, DEFAULT_SHARPNESS_LEVEL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | GST_VAAPI_PARAM_ENCODER_EXPOSURE); properties[ENCODER_VP9_PROP_YAC_Q_INDEX] = g_param_spec_uint ("yac-qi", "Luma AC Quant Table index", "Quantization Table index for Luma AC Coefficients", 0, 255, DEFAULT_YAC_QINDEX, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | GST_VAAPI_PARAM_ENCODER_EXPOSURE); properties[ENCODER_VP9_PROP_REF_PIC_MODE] = g_param_spec_enum ("ref-pic-mode", "RefPic Selection", "Reference Picture Selection Modes", gst_vaapi_encoder_vp9_ref_pic_mode_type (), GST_VAAPI_ENCODER_VP9_REF_PIC_MODE_0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | GST_VAAPI_PARAM_ENCODER_EXPOSURE); /** * GstVaapiEncoderVP9:cpb-length: * * The size of the Coded Picture Buffer , which means * the window size in milliseconds. * */ properties[ENCODER_VP9_PROP_CPB_LENGTH] = g_param_spec_uint ("cpb-length", "CPB Length", "Length of the CPB_buffer/window_size in milliseconds", 1, 10000, DEFAULT_CPB_LENGTH, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | GST_VAAPI_PARAM_ENCODER_EXPOSURE); g_object_class_install_properties (object_class, ENCODER_VP9_N_PROPERTIES, properties); } /** * gst_vaapi_encoder_vp9_new: * @display: a #GstVaapiDisplay * * Creates a new #GstVaapiEncoder for VP9 encoding. * * Return value: the newly allocated #GstVaapiEncoder object */ GstVaapiEncoder * gst_vaapi_encoder_vp9_new (GstVaapiDisplay * display) { return g_object_new (GST_TYPE_VAAPI_ENCODER_VP9, "display", display, NULL); }