From 5750bd7850256dcb812dcac7ff23eed910c62e84 Mon Sep 17 00:00:00 2001 From: Sreerenj Balachandran Date: Wed, 9 Aug 2017 18:36:13 -0700 Subject: [PATCH] FEI: plugin: Add vaapih264feienc element A new FEI based encoder element for h264 is added: vaapih264feienc FEI is a an extension to VA-API which is providing low level advanced control over different stages of encoding. Extending vaapih264enc with fei support is possible, but it will make the code too much complicated and will be difficult to debug. So adding the new encoder element, but keeping the rank as 0 , vaapih264enc will stay as the primary encoder for normal use cases. The vaaih264feienc is mainly useful for customers who want to play with MotionVectors and Macroblock Predictions. Also user can do one stage of encoding(eg: only the Motion Vector Calculation) in software and offload trasformation/entroy-coding etc to Hardware (which is what PAK module is doing) using FEI element. vaapih264feienc can work in different modes using fei-mode properoty eg: gst-launch-1.0 videotestsrc ! vaapih264feienc fei-mode=ENC+PAK ! filesink location=sample.264 Important Note: ENC only mode won't produce any encoded data which is expected. But ENC alwys requires the output of PAK in order to do the inter-prediction over reconstructed frames. Similary PAK mode alway requires MV and MBCode as input, so unless there is an upstream element providing those buffers, PAK only won't work as expected. In a nutshell, ENC_PAK and the ENC+PAK modes are the only options we can verify with vaapih264feienc. But ideally, EN+PAK mode verification is enough to make sure that ENC and PAK are working as expected since ENC+PAK mode always invoke ENC and PAK separately in vaapih264feienc. People contributed: Wang, Yi Leilei Zhong, Xiaoxia xiaominc Li, Jing B https://bugzilla.gnome.org/show_bug.cgi?id=785712 https://bugzilla.gnome.org/show_bug.cgi?id=784667 Signed-off-by: Sreerenj Balachandran --- gst/vaapi/Makefile.am | 14 +- gst/vaapi/gstvaapi.c | 13 + gst/vaapi/gstvaapiencode_h264_fei.c | 540 ++++++++++++++++++++++++++++++++++++ gst/vaapi/gstvaapiencode_h264_fei.h | 72 +++++ 4 files changed, 633 insertions(+), 6 deletions(-) create mode 100644 gst/vaapi/gstvaapiencode_h264_fei.c create mode 100644 gst/vaapi/gstvaapiencode_h264_fei.h diff --git a/gst/vaapi/Makefile.am b/gst/vaapi/Makefile.am index cfdc2f4..610acd1 100644 --- a/gst/vaapi/Makefile.am +++ b/gst/vaapi/Makefile.am @@ -122,12 +122,14 @@ libgstvaapi_source_c += $(libgstvaapi_vp9enc_source_c) libgstvaapi_source_h += $(libgstvaapi_vp9enc_source_h) endif -libgstvaapi_h264feienc_source_c = \ - gstvaapifeivideometa.c \ - $(NULL) -libgstvaapi_h264feienc_source_h = \ - gstvaapifeivideometa.h \ - $(NULL) +libgstvaapi_h264feienc_source_c = \ + gstvaapifeivideometa.c \ + gstvaapiencode_h264_fei.c \ + $(NULL) +libgstvaapi_h264feienc_source_h = \ + gstvaapifeivideometa.h \ + gstvaapiencode_h264_fei.h \ + $(NULL) if USE_H264_FEI_ENCODER libgstvaapi_source_c += $(libgstvaapi_h264feienc_source_c) diff --git a/gst/vaapi/gstvaapi.c b/gst/vaapi/gstvaapi.c index f060f8e..f8414a9 100644 --- a/gst/vaapi/gstvaapi.c +++ b/gst/vaapi/gstvaapi.c @@ -47,6 +47,11 @@ #if USE_VP9_ENCODER #include "gstvaapiencode_vp9.h" #endif + +#if USE_H264_FEI_ENCODER +#include "gstvaapiencode_h264_fei.h" +#endif + #endif #define PLUGIN_NAME "vaapi" @@ -186,6 +191,14 @@ gst_vaapiencode_register (GstPlugin * plugin, GstVaapiDisplay * display) } } +#if USE_H264_FEI_ENCODER + if (gst_vaapi_display_has_encoder (display, + GST_VAAPI_PROFILE_H264_MAIN, GST_VAAPI_ENTRYPOINT_SLICE_ENCODE_FEI)) { + gst_element_register (plugin, "vaapih264feienc", + GST_RANK_SECONDARY, GST_TYPE_VAAPIENCODE_H264_FEI); + } +#endif + g_array_unref (codecs); } #endif diff --git a/gst/vaapi/gstvaapiencode_h264_fei.c b/gst/vaapi/gstvaapiencode_h264_fei.c new file mode 100644 index 0000000..d44f063 --- /dev/null +++ b/gst/vaapi/gstvaapiencode_h264_fei.c @@ -0,0 +1,540 @@ +/* + * gstvaapiencode_h264_fei.c - VA-API H.264 FEI ncoder + * + * Copyright (C) 2016-2019 Intel Corporation + * Author: Sreerenj Balachandran + * Author: Yi A Wang + * + * 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 + */ + +/** + * SECTION:element-vaapih264feienc + * @short_description: A VA-API FEI based H.264 video encoder + * + * Encodes raw video streams into H.264 bitstreams. + * + * + * Example launch line + * |[ + * gst-launch-1.0 -ev videotestsrc num-buffers=60 ! vaapih264feienc fei-mode=ENC_PAK ! filesink location=test.264 + * ]| + * + */ + +#include "gstcompat.h" +#include +#include +#include +#include +#include +#include "gstvaapiencode_h264_fei.h" +#include "gstvaapipluginutil.h" +#include "gstvaapivideomemory.h" +#include "gstvaapifeivideometa.h" +#include + +#define GST_VAAPI_ENCODE_FLOW_MEM_ERROR GST_FLOW_CUSTOM_ERROR +#define GST_PLUGIN_NAME "vaapih264feienc" +#define GST_PLUGIN_DESC "A VA-API FEI based advanced H264 video encoder" + +GST_DEBUG_CATEGORY_STATIC (gst_vaapi_h264_fei_encode_debug); +#define GST_CAT_DEFAULT gst_vaapi_h264_fei_encode_debug + +#define GST_CODEC_CAPS \ + "video/x-h264, " \ + "stream-format = (string) { avc, byte-stream }, " \ + "alignment = (string) au" + +/* *INDENT-OFF* */ +static const char gst_vaapiencode_h264_fei_sink_caps_str[] = + GST_VAAPI_MAKE_SURFACE_CAPS ", " + GST_CAPS_INTERLACED_FALSE "; " + GST_VIDEO_CAPS_MAKE (GST_VIDEO_FORMATS_ALL) ", " + GST_CAPS_INTERLACED_FALSE; +/* *INDENT-ON* */ + +/* *INDENT-OFF* */ +static const char gst_vaapiencode_h264_fei_src_caps_str[] = + GST_CODEC_CAPS ", " + "profile = (string) { constrained-baseline, baseline, main, high, multiview-high, stereo-high }"; +/* *INDENT-ON* */ + +/* *INDENT-OFF* */ +static GstStaticPadTemplate gst_vaapiencode_h264_fei_sink_factory = + GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (gst_vaapiencode_h264_fei_sink_caps_str)); +/* *INDENT-ON* */ + +/* *INDENT-OFF* */ +static GstStaticPadTemplate gst_vaapiencode_h264_fei_src_factory = + GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (gst_vaapiencode_h264_fei_src_caps_str)); +/* *INDENT-ON* */ + +/* h264 encode */ +G_DEFINE_TYPE (GstVaapiEncodeH264Fei, gst_vaapiencode_h264_fei, + GST_TYPE_VAAPIENCODE); + +static void +gst_vaapiencode_h264_fei_init (GstVaapiEncodeH264Fei * encode) +{ + gst_vaapiencode_init_properties (GST_VAAPIENCODE_CAST (encode)); +} + +static void +gst_vaapiencode_h264_fei_finalize (GObject * object) +{ + G_OBJECT_CLASS (gst_vaapiencode_h264_fei_parent_class)->finalize (object); +} + +static void +gst_vaapiencode_h264_fei_set_property (GObject * object, + guint prop_id, const GValue * value, GParamSpec * pspec) +{ + GstVaapiEncodeClass *const encode_class = GST_VAAPIENCODE_GET_CLASS (object); + GstVaapiEncode *const base_encode = GST_VAAPIENCODE_CAST (object); + + switch (prop_id) { + default: + if (!encode_class->set_property (base_encode, prop_id, value)) + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_vaapiencode_h264_fei_get_property (GObject * object, + guint prop_id, GValue * value, GParamSpec * pspec) +{ + GstVaapiEncodeClass *const encode_class = GST_VAAPIENCODE_GET_CLASS (object); + GstVaapiEncode *const base_encode = GST_VAAPIENCODE_CAST (object); + + switch (prop_id) { + default: + if (!encode_class->get_property (base_encode, prop_id, value)) + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +typedef struct +{ + GstVaapiProfile best_profile; + guint best_score; +} FindBestProfileData; + +static void +find_best_profile_value (FindBestProfileData * data, const GValue * value) +{ + const gchar *str; + GstVaapiProfile profile; + guint score; + + if (!value || !G_VALUE_HOLDS_STRING (value)) + return; + + str = g_value_get_string (value); + if (!str) + return; + profile = gst_vaapi_utils_h264_get_profile_from_string (str); + if (!profile) + return; + score = gst_vaapi_utils_h264_get_profile_score (profile); + if (score < data->best_score) + return; + data->best_profile = profile; + data->best_score = score; +} + +static GstVaapiProfile +find_best_profile (GstCaps * caps) +{ + FindBestProfileData data; + guint i, j, num_structures, num_values; + + data.best_profile = GST_VAAPI_PROFILE_UNKNOWN; + data.best_score = 0; + + num_structures = gst_caps_get_size (caps); + for (i = 0; i < num_structures; i++) { + GstStructure *const structure = gst_caps_get_structure (caps, i); + const GValue *const value = gst_structure_get_value (structure, "profile"); + + if (!value) + continue; + if (G_VALUE_HOLDS_STRING (value)) + find_best_profile_value (&data, value); + else if (GST_VALUE_HOLDS_LIST (value)) { + num_values = gst_value_list_get_size (value); + for (j = 0; j < num_values; j++) + find_best_profile_value (&data, gst_value_list_get_value (value, j)); + } + } + return data.best_profile; +} + +static gboolean +gst_vaapiencode_h264_fei_set_config (GstVaapiEncode * base_encode) +{ + GstVaapiEncoderH264Fei *const encoder = + GST_VAAPI_ENCODER_H264_FEI (base_encode->encoder); + GstCaps *allowed_caps; + GstVaapiProfile profile; + + /* Check for the largest profile that is supported */ + allowed_caps = + gst_pad_get_allowed_caps (GST_VAAPI_PLUGIN_BASE_SRC_PAD (base_encode)); + if (!allowed_caps) + return TRUE; + + profile = find_best_profile (allowed_caps); + gst_caps_unref (allowed_caps); + if (profile) { + GST_INFO ("using %s profile as target decoder constraints", + gst_vaapi_utils_h264_get_profile_string (profile)); + if (!gst_vaapi_encoder_h264_fei_set_max_profile (encoder, profile)) + return FALSE; + } + return TRUE; +} + +static GstCaps * +gst_vaapiencode_h264_fei_get_caps (GstVaapiEncode * base_encode) +{ + GstVaapiEncodeH264Fei *const encode = + GST_VAAPIENCODE_H264_FEI_CAST (base_encode); + GstCaps *caps, *allowed_caps; + + caps = gst_caps_from_string (GST_CODEC_CAPS); + + /* Check whether "stream-format" is avcC mode */ + allowed_caps = + gst_pad_get_allowed_caps (GST_VAAPI_PLUGIN_BASE_SRC_PAD (encode)); + if (allowed_caps) { + const char *stream_format = NULL; + GstStructure *structure; + guint i, num_structures; + + num_structures = gst_caps_get_size (allowed_caps); + for (i = 0; !stream_format && i < num_structures; i++) { + structure = gst_caps_get_structure (allowed_caps, i); + if (!gst_structure_has_field_typed (structure, "stream-format", + G_TYPE_STRING)) + continue; + stream_format = gst_structure_get_string (structure, "stream-format"); + } + encode->is_avc = stream_format && strcmp (stream_format, "avc") == 0; + gst_caps_unref (allowed_caps); + } + gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, + encode->is_avc ? "avc" : "byte-stream", NULL); + + base_encode->need_codec_data = encode->is_avc; + + /* XXX: update profile and level information */ + return caps; +} + +static GstVaapiEncoder * +gst_vaapiencode_h264_fei_alloc_encoder (GstVaapiEncode * base, + GstVaapiDisplay * display) +{ + return gst_vaapi_encoder_h264_fei_new (display); +} + +/* h264 NAL byte stream operations */ +static guint8 * +_h264_byte_stream_next_nal (guint8 * buffer, guint32 len, guint32 * nal_size) +{ + const guint8 *cur = buffer; + const guint8 *const end = buffer + len; + guint8 *nal_start = NULL; + guint32 flag = 0xFFFFFFFF; + guint32 nal_start_len = 0; + + g_assert (len >= 0 && buffer && nal_size); + if (len < 3) { + *nal_size = len; + nal_start = (len ? buffer : NULL); + return nal_start; + } + + /*locate head postion */ + if (!buffer[0] && !buffer[1]) { + if (buffer[2] == 1) { /* 0x000001 */ + nal_start_len = 3; + } else if (!buffer[2] && len >= 4 && buffer[3] == 1) { /* 0x00000001 */ + nal_start_len = 4; + } + } + nal_start = buffer + nal_start_len; + cur = nal_start; + + /*find next nal start position */ + while (cur < end) { + flag = ((flag << 8) | ((*cur++) & 0xFF)); + if ((flag & 0x00FFFFFF) == 0x00000001) { + if (flag == 0x00000001) + *nal_size = cur - 4 - nal_start; + else + *nal_size = cur - 3 - nal_start; + break; + } + } + if (cur >= end) { + *nal_size = end - nal_start; + if (nal_start >= end) { + nal_start = NULL; + } + } + return nal_start; +} + +static inline void +_start_code_to_size (guint8 nal_start_code[4], guint32 nal_size) +{ + nal_start_code[0] = ((nal_size >> 24) & 0xFF); + nal_start_code[1] = ((nal_size >> 16) & 0xFF); + nal_start_code[2] = ((nal_size >> 8) & 0xFF); + nal_start_code[3] = (nal_size & 0xFF); +} + +static gboolean +_h264_convert_byte_stream_to_avc (GstBuffer * buf) +{ + GstMapInfo info; + guint32 nal_size; + guint8 *nal_start_code, *nal_body; + guint8 *frame_end; + + g_assert (buf); + + if (!gst_buffer_map (buf, &info, GST_MAP_READ | GST_MAP_WRITE)) + return FALSE; + + nal_start_code = info.data; + frame_end = info.data + info.size; + nal_size = 0; + + while ((frame_end > nal_start_code) && + (nal_body = _h264_byte_stream_next_nal (nal_start_code, + frame_end - nal_start_code, &nal_size)) != NULL) { + if (!nal_size) + goto error; + + g_assert (nal_body - nal_start_code == 4); + _start_code_to_size (nal_start_code, nal_size); + nal_start_code = nal_body + nal_size; + } + gst_buffer_unmap (buf, &info); + return TRUE; + + /* ERRORS */ +error: + { + gst_buffer_unmap (buf, &info); + return FALSE; + } +} + +static GstFlowReturn +alloc_buffer (GstVaapiEncode * encode, + GstVaapiCodedBuffer * coded_buf, GstBuffer ** outbuf_ptr) +{ + GstVaapiEncoderH264Fei *const encoder = + GST_VAAPI_ENCODER_H264_FEI (encode->encoder); + GstBuffer *buf; + gint32 buf_size; + GstVaapiFeiMode fei_mode; + + g_return_val_if_fail (coded_buf != NULL, GST_FLOW_ERROR); + g_return_val_if_fail (outbuf_ptr != NULL, GST_FLOW_ERROR); + + fei_mode = gst_vaapi_encoder_h264_fei_get_function_mode (encoder); + + if (fei_mode == GST_VAAPI_FEI_MODE_ENC) + buf_size = 4; /* just avoid zero size buffer allocation */ + else + buf_size = gst_vaapi_coded_buffer_get_size (coded_buf); + + if (buf_size <= 0) + goto error_invalid_buffer; + + buf = + gst_video_encoder_allocate_output_buffer (GST_VIDEO_ENCODER_CAST (encode), + buf_size); + if (!buf) + goto error_create_buffer; + + /* There is no encoded output content in ENC only mode */ + if (fei_mode != GST_VAAPI_FEI_MODE_ENC) { + if (!gst_vaapi_coded_buffer_copy_into (buf, coded_buf)) + goto error_copy_buffer; + } + + *outbuf_ptr = buf; + return GST_FLOW_OK; + + /* ERRORS */ +error_invalid_buffer: + { + GST_ERROR ("invalid GstVaapiCodedBuffer size (%d bytes)", buf_size); + return GST_VAAPI_ENCODE_FLOW_MEM_ERROR; + } +error_create_buffer: + { + GST_ERROR ("failed to create output buffer of size %d", buf_size); + return GST_VAAPI_ENCODE_FLOW_MEM_ERROR; + } +error_copy_buffer: + { + GST_ERROR ("failed to copy GstVaapiCodedBuffer data"); + gst_buffer_unref (buf); + return GST_VAAPI_ENCODE_FLOW_MEM_ERROR; + } +} + +static GstFlowReturn +gst_vaapiencode_h264_fei_alloc_buffer (GstVaapiEncode * base_encode, + GstVaapiCodedBuffer * coded_buf, GstBuffer ** out_buffer_ptr) +{ + GstVaapiEncodeH264Fei *const encode = + GST_VAAPIENCODE_H264_FEI_CAST (base_encode); + GstVaapiEncoderH264Fei *const encoder = + GST_VAAPI_ENCODER_H264_FEI (base_encode->encoder); + GstFlowReturn ret; + + g_return_val_if_fail (encoder != NULL, GST_FLOW_ERROR); + + ret = alloc_buffer (base_encode, coded_buf, out_buffer_ptr); + if (ret != GST_FLOW_OK) + return ret; + + if (!encode->is_avc) + return GST_FLOW_OK; + + /* Convert to avcC format */ + if (!_h264_convert_byte_stream_to_avc (*out_buffer_ptr)) + goto error_convert_buffer; + return GST_FLOW_OK; + + /* ERRORS */ +error_convert_buffer: + { + GST_ERROR ("failed to convert from bytestream format to avcC format"); + gst_buffer_replace (out_buffer_ptr, NULL); + return GST_FLOW_ERROR; + } +} + +static gboolean +gst_vaapiencode_h264_load_control_data (GstVaapiEncode * base_encode, + GstVaapiFeiVideoMeta * feimeta, GstVaapiSurfaceProxy * proxy) +{ + if (feimeta != NULL) { + gst_vaapi_surface_proxy_set_fei_mb_code (proxy, feimeta->mbcode); + gst_vaapi_surface_proxy_set_fei_mv (proxy, feimeta->mv); + gst_vaapi_surface_proxy_set_fei_mv_predictor (proxy, feimeta->mvpred); + gst_vaapi_surface_proxy_set_fei_mb_control (proxy, feimeta->mbcntrl); + gst_vaapi_surface_proxy_set_fei_qp (proxy, feimeta->qp); + gst_vaapi_surface_proxy_set_fei_distortion (proxy, feimeta->dist); + } + return TRUE; + +} + +static GstVaapiFeiVideoMeta * +gst_vaapiencode_h264_save_stats_to_meta (GstVaapiEncode * base_encode, + GstVaapiCodedBufferProxy * proxy) +{ + GstVaapiEncoderH264Fei *const encoder = + GST_VAAPI_ENCODER_H264_FEI (base_encode->encoder); + GstVaapiFeiVideoMeta *feimeta = NULL; + GstVaapiEncFeiMbCode *mbcode = NULL; + GstVaapiEncFeiMv *mv = NULL; + GstVaapiEncFeiDistortion *dist = NULL; + + if (!gst_vaapi_encoder_h264_is_fei_stats_out_enabled (encoder)) + return NULL; + + feimeta = gst_vaapi_fei_video_meta_new (); + if (feimeta == NULL) + return NULL; + + mbcode = gst_vaapi_coded_buffer_proxy_get_fei_mbcode (proxy); + if (mbcode) + feimeta->mbcode = (GstVaapiEncFeiMbCode *) + gst_vaapi_fei_codec_object_ref ((GstVaapiFeiCodecObject *) mbcode); + + mv = gst_vaapi_coded_buffer_proxy_get_fei_mv (proxy); + if (mv) + feimeta->mv = (GstVaapiEncFeiMv *) + gst_vaapi_fei_codec_object_ref ((GstVaapiFeiCodecObject *) mv); + + dist = gst_vaapi_coded_buffer_proxy_get_fei_distortion (proxy); + if (dist) + feimeta->dist = (GstVaapiEncFeiDistortion *) + gst_vaapi_fei_codec_object_ref ((GstVaapiFeiCodecObject *) dist); + + return feimeta; +} + +static void +gst_vaapiencode_h264_fei_class_init (GstVaapiEncodeH264FeiClass * klass) +{ + GObjectClass *const object_class = G_OBJECT_CLASS (klass); + GstElementClass *const element_class = GST_ELEMENT_CLASS (klass); + GstVaapiEncodeClass *const encode_class = GST_VAAPIENCODE_CLASS (klass); + + GST_DEBUG_CATEGORY_INIT (gst_vaapi_h264_fei_encode_debug, + GST_PLUGIN_NAME, 0, GST_PLUGIN_DESC); + + object_class->finalize = gst_vaapiencode_h264_fei_finalize; + object_class->set_property = gst_vaapiencode_h264_fei_set_property; + object_class->get_property = gst_vaapiencode_h264_fei_get_property; + + encode_class->get_properties = + gst_vaapi_encoder_h264_fei_get_default_properties; + encode_class->set_config = gst_vaapiencode_h264_fei_set_config; + encode_class->get_caps = gst_vaapiencode_h264_fei_get_caps; + encode_class->alloc_encoder = gst_vaapiencode_h264_fei_alloc_encoder; + encode_class->alloc_buffer = gst_vaapiencode_h264_fei_alloc_buffer; + + encode_class->load_control_data = gst_vaapiencode_h264_load_control_data; + encode_class->save_stats_to_meta = gst_vaapiencode_h264_save_stats_to_meta; + + gst_element_class_set_static_metadata (element_class, + "VA-API H264 FEI Advanced encoder (Experimental)", + "Codec/Encoder/Video", + GST_PLUGIN_DESC, + "Sreerenj Balachandran ," + "Yi A Wang "); + + /* sink pad */ + gst_element_class_add_static_pad_template (element_class, + &gst_vaapiencode_h264_fei_sink_factory); + + /* src pad */ + gst_element_class_add_static_pad_template (element_class, + &gst_vaapiencode_h264_fei_src_factory); + + gst_vaapiencode_class_init_properties (encode_class); +} diff --git a/gst/vaapi/gstvaapiencode_h264_fei.h b/gst/vaapi/gstvaapiencode_h264_fei.h new file mode 100644 index 0000000..1950107 --- /dev/null +++ b/gst/vaapi/gstvaapiencode_h264_fei.h @@ -0,0 +1,72 @@ +/* + * gstvaapiencode_h264i_fei.h - VA-API H.264 FEI encoder + * + * Copyright (C) 2016-2017 Intel Corporation + * Author: Sreerenj Balachandran + * Author: Yi A Wang + * + * 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 + */ + +#ifndef GST_VAAPIENCODE_H264_FEI_FEI_H +#define GST_VAAPIENCODE_H264_FEI_FEI_H + +#include +#include "gstvaapiencode.h" + +G_BEGIN_DECLS + +#define GST_TYPE_VAAPIENCODE_H264_FEI \ + (gst_vaapiencode_h264_fei_get_type ()) +#define GST_VAAPIENCODE_H264_FEI_CAST(obj) \ + ((GstVaapiEncodeH264Fei *)(obj)) +#define GST_VAAPIENCODE_H264_FEI(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPIENCODE_H264_FEI, \ + GstVaapiEncodeH264Fei)) +#define GST_VAAPIENCODE_H264_FEI_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPIENCODE_H264_FEI, \ + GstVaapiEncodeH264FeiClass)) +#define GST_VAAPIENCODE_H264_FEI_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPIENCODE_H264_FEI, \ + GstVaapiEncodeH264FeiClass)) +#define GST_IS_VAAPIENCODE_H264_FEI(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPIENCODE_H264_FEI)) +#define GST_IS_VAAPIENCODE_H264_FEI_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPIENCODE_H264_FEI)) + +typedef struct _GstVaapiEncodeH264Fei GstVaapiEncodeH264Fei; +typedef struct _GstVaapiEncodeH264FeiClass GstVaapiEncodeH264FeiClass; + +struct _GstVaapiEncodeH264Fei +{ + /*< private >*/ + GstVaapiEncode parent_instance; + + guint is_avc:1; /* [FALSE]=byte-stream (default); [TRUE]=avcC */ +}; + +struct _GstVaapiEncodeH264FeiClass +{ + /*< private >*/ + GstVaapiEncodeClass parent_class; +}; + +GType +gst_vaapiencode_h264_fei_get_type (void) G_GNUC_CONST; + +G_END_DECLS + +#endif /* GST_VAAPIENCODE_H264_FEI_FEI_H */ -- 2.7.4