--- /dev/null
+/* GStreamer
+ * Copyright (C) 2022 Igalia, S.L.
+ * Author: Víctor Jáquez <vjaquez@igalia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the0
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+/**
+ * SECTION:element-vajpegdec
+ * @title: vajpegdec
+ * @short_description: A VA-API based JPEG video decoder
+ *
+ * vajpegdec decodes JPEG images to VA surfaces using the installed
+ * and chosen [VA-API](https://01.org/linuxmedia/vaapi) driver.
+ *
+ * The decoding surfaces can be mapped onto main memory as video
+ * frames.
+ *
+ * ## Example launch line
+ * ```
+ * gst-launch-1.0 filesrc location=sample.mjpg ! parsebin ! vajpegdec ! autovideosink
+ * ```
+ *
+ * Since: 1.22
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstvajpegdec.h"
+
+#include "gstvabasedec.h"
+
+GST_DEBUG_CATEGORY_STATIC (gst_va_jpegdec_debug);
+#ifndef GST_DISABLE_GST_DEBUG
+#define GST_CAT_DEFAULT gst_va_jpegdec_debug
+#else
+#define GST_CAT_DEFAULT NULL
+#endif
+
+#define GST_VA_JPEG_DEC(obj) ((GstVaJpegDec *) obj)
+#define GST_VA_JPEG_DEC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_FROM_INSTANCE (obj), GstVaJPEGDecClass))
+#define GST_VA_JPEG_DEC_CLASS(klass) ((GstVaJpegDecClass *) klass)
+
+typedef struct _GstVaJpegDec GstVaJpegDec;
+typedef struct _GstVaJpegDecClass GstVaJpegDecClass;
+
+struct _GstVaJpegDecClass
+{
+ GstVaBaseDecClass parent_class;
+};
+
+struct _GstVaJpegDec
+{
+ GstVaBaseDec parent;
+
+ GstVaDecodePicture *pic;
+};
+
+static GstElementClass *parent_class = NULL;
+
+/* *INDENT-OFF* */
+static const gchar *src_caps_str =
+ GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_MEMORY_VA,
+ "{ NV12 }") " ;"
+ GST_VIDEO_CAPS_MAKE ("{ NV12 }");
+/* *INDENT-ON* */
+
+static const gchar *sink_caps_str = "image/jpeg";
+
+static VAProfile
+_get_profile (GstJpegMarker marker)
+{
+ switch (marker) {
+ case GST_JPEG_MARKER_SOF0:
+ return VAProfileJPEGBaseline;
+ default:
+ break;
+ };
+
+ return VAProfileNone;
+}
+
+/* taken from MediaSDK */
+#define RT_FORMAT_RGB (VA_RT_FORMAT_RGB16 | VA_RT_FORMAT_RGB32)
+
+/* *INDENT-OFF* */
+static const struct sampling_rtformat {
+ const gchar *sampling;
+ guint32 rt_format;
+} sampling_rtformat_map[] = {
+ { "RGB", RT_FORMAT_RGB },
+ { "YCbCr-4:4:4", VA_RT_FORMAT_YUV444 },
+ { "YCbCr-4:2:2", VA_RT_FORMAT_YUV422 },
+ { "YCbCr-4:2:0", VA_RT_FORMAT_YUV420 },
+ { "GRAYSCALE", VA_RT_FORMAT_YUV400 },
+ { "YCbCr-4:1:1", VA_RT_FORMAT_YUV411 },
+};
+/* *INDENT-ON* */
+
+static guint32
+_get_rt_format (GstCaps * caps)
+{
+ GstStructure *structure;
+ const gchar *sampling;
+ guint i;
+
+ structure = gst_caps_get_structure (caps, 0);
+ sampling = gst_structure_get_string (structure, "sampling");
+
+ for (i = 0; i < G_N_ELEMENTS (sampling_rtformat_map); i++) {
+ if (g_strcmp0 (sampling, sampling_rtformat_map[i].sampling) == 0)
+ return sampling_rtformat_map[i].rt_format;
+ }
+
+ return 0;
+}
+
+static GstFlowReturn
+gst_va_jpeg_dec_new_picture (GstJpegDecoder * decoder,
+ GstVideoCodecFrame * frame, GstJpegMarker marker,
+ GstJpegFrameHdr * frame_hdr)
+{
+ GstVaJpegDec *self = GST_VA_JPEG_DEC (decoder);
+ GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
+ GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+ GstFlowReturn ret;
+ VAProfile profile;
+ VAPictureParameterBufferJPEGBaseline pic_param;
+ guint32 i, rt_format;
+
+ GST_LOG_OBJECT (self, "new picture");
+
+ g_clear_pointer (&self->pic, gst_va_decode_picture_free);
+
+ profile = _get_profile (marker);
+ if (profile == VAProfileNone)
+ return GST_FLOW_NOT_NEGOTIATED;
+
+ /* use caps to avoid re-parsing app14 */
+ rt_format = _get_rt_format (decoder->input_state->caps);
+ if (rt_format == 0)
+ return GST_FLOW_NOT_NEGOTIATED;
+
+ if (!gst_va_decoder_config_is_equal (base->decoder, profile, rt_format,
+ frame_hdr->width, frame_hdr->height)) {
+ base->profile = profile;
+ base->rt_format = rt_format;
+ base->width = frame_hdr->width;
+ base->height = frame_hdr->height;
+
+ base->need_negotiation = TRUE;
+ GST_INFO_OBJECT (self, "Format changed to %s [%x] (%dx%d)",
+ gst_va_profile_name (profile), rt_format, base->width, base->height);
+ }
+
+ if (base->need_negotiation) {
+ if (!gst_video_decoder_negotiate (vdec)) {
+ GST_ERROR_OBJECT (self, "Failed to negotiate with downstream");
+ return GST_FLOW_NOT_NEGOTIATED;
+ }
+ }
+
+ ret = gst_video_decoder_allocate_output_frame (vdec, frame);
+ if (ret != GST_FLOW_OK) {
+ GST_ERROR_OBJECT (self, "Failed to allocate output buffer: %s",
+ gst_flow_get_name (ret));
+ return ret;
+ }
+
+ self->pic = gst_va_decode_picture_new (base->decoder, frame->output_buffer);
+
+ /* *INDENT-OFF* */
+ pic_param = (VAPictureParameterBufferJPEGBaseline) {
+ .picture_width = frame_hdr->width,
+ .picture_height = frame_hdr->height,
+ /* .components */
+ .num_components = frame_hdr->num_components,
+ .color_space = (rt_format == RT_FORMAT_RGB) ? 1 : 0, /* TODO: BGR */
+ .rotation = VA_ROTATION_NONE,
+ };
+ /* *INDENT-ON* */
+
+ for (i = 0; i < frame_hdr->num_components; i++) {
+ pic_param.components[i].component_id = frame_hdr->components[i].identifier;
+ pic_param.components[i].h_sampling_factor =
+ frame_hdr->components[i].horizontal_factor;
+ pic_param.components[i].v_sampling_factor =
+ frame_hdr->components[i].vertical_factor;
+ pic_param.components[i].quantiser_table_selector =
+ frame_hdr->components[i].quant_table_selector;
+ }
+
+ if (!gst_va_decoder_add_param_buffer (base->decoder, self->pic,
+ VAPictureParameterBufferType, &pic_param, sizeof (pic_param)))
+ return GST_FLOW_ERROR;
+
+ return ret;
+}
+
+static GstFlowReturn
+gst_va_jpeg_dec_decode_scan (GstJpegDecoder * decoder,
+ GstJpegDecoderScan * scan, const guint8 * buffer, guint32 size)
+{
+ GstVaJpegDec *self = GST_VA_JPEG_DEC (decoder);
+ GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+ VAHuffmanTableBufferJPEGBaseline huff = { 0, };
+ VAIQMatrixBufferJPEGBaseline quant = { 0, };
+ VASliceParameterBufferJPEGBaseline slice_param;
+ guint i, j;
+
+ GST_LOG_OBJECT (self, "decoding slice");
+
+ for (i = 0; i < G_N_ELEMENTS (quant.load_quantiser_table); i++) {
+ quant.load_quantiser_table[i] =
+ scan->quantization_tables->quant_tables[i].valid;
+ if (!scan->quantization_tables->quant_tables[i].valid)
+ continue;
+ for (j = 0; j < GST_JPEG_MAX_QUANT_ELEMENTS; j++) {
+ quant.quantiser_table[i][j] =
+ scan->quantization_tables->quant_tables[i].quant_table[j];
+ }
+
+ /* invalidate table */
+ scan->quantization_tables->quant_tables[i].valid = FALSE;
+ }
+
+ if (!gst_va_decoder_add_param_buffer (base->decoder, self->pic,
+ VAIQMatrixBufferType, &quant, sizeof (quant)))
+ return GST_FLOW_ERROR;
+
+ for (i = 0; i < G_N_ELEMENTS (huff.huffman_table); i++) {
+ huff.load_huffman_table[i] = scan->huffman_tables->dc_tables[i].valid
+ && scan->huffman_tables->ac_tables[i].valid;
+
+ if (!huff.load_huffman_table[i])
+ continue;
+
+ memcpy (huff.huffman_table[i].num_dc_codes,
+ scan->huffman_tables->dc_tables[i].huf_bits,
+ sizeof (huff.huffman_table[i].num_dc_codes));
+
+ memcpy (huff.huffman_table[i].dc_values,
+ scan->huffman_tables->dc_tables[i].huf_values,
+ sizeof (huff.huffman_table[i].dc_values));
+
+ memcpy (huff.huffman_table[i].num_ac_codes,
+ scan->huffman_tables->ac_tables[i].huf_bits,
+ sizeof (huff.huffman_table[i].num_ac_codes));
+
+ memcpy (huff.huffman_table[i].ac_values,
+ scan->huffman_tables->ac_tables[i].huf_values,
+ sizeof (huff.huffman_table[i].ac_values));
+ }
+
+
+ /* invalidate table */
+ for (i = 0; i < G_N_ELEMENTS (scan->huffman_tables->dc_tables); i++)
+ scan->huffman_tables->dc_tables[i].valid = FALSE;
+ for (i = 0; i < G_N_ELEMENTS (scan->huffman_tables->ac_tables); i++)
+ scan->huffman_tables->ac_tables[i].valid = FALSE;
+
+ if (!gst_va_decoder_add_param_buffer (base->decoder, self->pic,
+ VAHuffmanTableBufferType, &huff, sizeof (huff)))
+ return GST_FLOW_ERROR;
+
+ /* *INDENT-OFF* */
+ slice_param = (VASliceParameterBufferJPEGBaseline) {
+ .slice_data_size = size,
+ .slice_data_offset = 0,
+ .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
+ .slice_horizontal_position = 0,
+ .slice_vertical_position = 0,
+ .restart_interval = scan->restart_interval,
+ .num_mcus = scan->mcu_rows_in_scan * scan->mcus_per_row,
+ .num_components = scan->scan_hdr->num_components,
+ };
+ /* *INDENT-ON* */
+
+ for (i = 0; i < scan->scan_hdr->num_components; i++) {
+ slice_param.components[i].component_selector =
+ scan->scan_hdr->components[i].component_selector;
+ slice_param.components[i].dc_table_selector =
+ scan->scan_hdr->components[i].dc_selector;
+ slice_param.components[i].ac_table_selector =
+ scan->scan_hdr->components[i].ac_selector;
+ }
+
+ if (!gst_va_decoder_add_slice_buffer (base->decoder, self->pic, &slice_param,
+ sizeof (slice_param), (void *) buffer, size))
+ return GST_FLOW_ERROR;
+
+ return GST_FLOW_OK;
+}
+
+static GstFlowReturn
+gst_va_jpeg_dec_end_picture (GstJpegDecoder * decoder)
+{
+ GstVaJpegDec *self = GST_VA_JPEG_DEC (decoder);
+ GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+
+ GST_LOG_OBJECT (self, "end picture");
+
+ if (!gst_va_decoder_decode (base->decoder, self->pic))
+ return GST_FLOW_ERROR;
+ return GST_FLOW_OK;
+}
+
+static GstFlowReturn
+gst_va_jpeg_dec_output_picture (GstJpegDecoder * decoder,
+ GstVideoCodecFrame * frame)
+{
+ GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
+ GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+
+ if (base->copy_frames)
+ gst_va_base_dec_copy_output_buffer (base, frame);
+ return gst_video_decoder_finish_frame (vdec, frame);
+}
+
+static gboolean
+gst_va_jpeg_dec_negotiate (GstVideoDecoder * decoder)
+{
+ GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
+ GstVaJpegDec *self = GST_VA_JPEG_DEC (decoder);
+ GstJpegDecoder *jpegdec = GST_JPEG_DECODER (decoder);
+ GstVideoFormat format;
+ GstCapsFeatures *capsfeatures = NULL;
+
+ /* Ignore downstream renegotiation request. */
+ if (!base->need_negotiation)
+ return TRUE;
+
+ base->need_negotiation = FALSE;
+
+ if (GST_VA_DISPLAY_IS_IMPLEMENTATION (base->display, INTEL_I965))
+ base->hacks = GST_VA_HACK_SURFACE_NO_FOURCC;
+
+ if (gst_va_decoder_is_open (base->decoder)
+ && !gst_va_decoder_close (base->decoder))
+ return FALSE;
+
+ if (!gst_va_decoder_open (base->decoder, base->profile, base->rt_format))
+ return FALSE;
+
+ if (!gst_va_decoder_set_frame_size (base->decoder, base->width, base->height))
+ return FALSE;
+
+ if (base->output_state)
+ gst_video_codec_state_unref (base->output_state);
+
+ /* hack for RGBP rt_format */
+ if (base->rt_format == RT_FORMAT_RGB)
+ base->rt_format = VA_RT_FORMAT_RGBP;
+
+ gst_va_base_dec_get_preferred_format_and_caps_features (base, &format,
+ &capsfeatures);
+ if (format == GST_VIDEO_FORMAT_UNKNOWN)
+ return FALSE;
+
+ if (gst_va_chroma_from_video_format (format) != base->rt_format)
+ return FALSE;
+
+ /* hack for RGBP rt_format */
+ if (base->rt_format == VA_RT_FORMAT_RGBP)
+ base->rt_format = RT_FORMAT_RGB;
+
+ base->output_state =
+ gst_video_decoder_set_output_state (decoder, format,
+ base->width, base->height, jpegdec->input_state);
+
+ base->output_state->caps = gst_video_info_to_caps (&base->output_state->info);
+ if (capsfeatures)
+ gst_caps_set_features_simple (base->output_state->caps, capsfeatures);
+
+ GST_INFO_OBJECT (self, "Negotiated caps %" GST_PTR_FORMAT,
+ base->output_state->caps);
+
+ return GST_VIDEO_DECODER_CLASS (parent_class)->negotiate (decoder);
+}
+
+static void
+gst_va_jpeg_dec_dispose (GObject * object)
+{
+ GstVaJpegDec *self = GST_VA_JPEG_DEC (object);
+
+ gst_va_base_dec_close (GST_VIDEO_DECODER (object));
+ g_clear_pointer (&self->pic, gst_va_decode_picture_free);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gst_va_jpeg_dec_class_init (gpointer g_class, gpointer class_data)
+{
+ GstCaps *src_doc_caps, *sink_doc_caps;
+ GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
+ GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+ GstJpegDecoderClass *jpegdecoder_class = GST_JPEG_DECODER_CLASS (g_class);
+ GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_CLASS (g_class);
+ struct CData *cdata = class_data;
+ gchar *long_name;
+
+ if (cdata->description) {
+ long_name = g_strdup_printf ("VA-API JPEG Decoder in %s",
+ cdata->description);
+ } else {
+ long_name = g_strdup ("VA-API JPEG Decoder");
+ }
+
+ gst_element_class_set_metadata (element_class, long_name,
+ "Codec/Decoder/Image/Hardware",
+ "VA-API based JPEG image decoder",
+ "Víctor Jáquez <vjaquez@igalia.com>");
+
+ sink_doc_caps = gst_caps_from_string (sink_caps_str);
+ src_doc_caps = gst_caps_from_string (src_caps_str);
+
+ parent_class = g_type_class_peek_parent (g_class);
+
+ gobject_class->dispose = gst_va_jpeg_dec_dispose;
+
+ decoder_class->negotiate = GST_DEBUG_FUNCPTR (gst_va_jpeg_dec_negotiate);
+
+ jpegdecoder_class->decode_scan =
+ GST_DEBUG_FUNCPTR (gst_va_jpeg_dec_decode_scan);
+ jpegdecoder_class->new_picture =
+ GST_DEBUG_FUNCPTR (gst_va_jpeg_dec_new_picture);
+ jpegdecoder_class->end_picture =
+ GST_DEBUG_FUNCPTR (gst_va_jpeg_dec_end_picture);
+ jpegdecoder_class->output_picture =
+ GST_DEBUG_FUNCPTR (gst_va_jpeg_dec_output_picture);
+
+ gst_va_base_dec_class_init (GST_VA_BASE_DEC_CLASS (g_class), JPEG,
+ cdata->render_device_path, cdata->sink_caps, cdata->src_caps,
+ src_doc_caps, sink_doc_caps);
+
+ g_free (long_name);
+ g_free (cdata->description);
+ g_free (cdata->render_device_path);
+ gst_caps_unref (cdata->src_caps);
+ gst_caps_unref (cdata->sink_caps);
+ g_free (cdata);
+}
+
+static void
+gst_va_jpeg_dec_init (GTypeInstance * instance, gpointer g_class)
+{
+ GstVaBaseDec *base = GST_VA_BASE_DEC (instance);
+
+ gst_va_base_dec_init (base, GST_CAT_DEFAULT);
+ base->min_buffers = 1;
+}
+
+static gpointer
+_register_debug_category (gpointer data)
+{
+ GST_DEBUG_CATEGORY_INIT (gst_va_jpegdec_debug, "vajpegdec", 0,
+ "VA jpeg decoder");
+
+ return NULL;
+}
+
+static GstCaps *
+_fixup_sink_caps (GstVaDisplay * display, GstCaps * caps)
+{
+ if (GST_VA_DISPLAY_IS_IMPLEMENTATION (display, INTEL_I965)) {
+ guint i;
+ GstCaps *ret;
+ GValue sampling = G_VALUE_INIT;
+ const char *sampling_list[] = { "YCbCr-4:2:0", "YCbCr-4:2:2" };
+
+ ret = gst_caps_copy (caps);
+ gst_caps_set_simple (ret, "colorspace", G_TYPE_STRING, "sYUV", NULL);
+
+ gst_value_list_init (&sampling, G_N_ELEMENTS (sampling_list));
+ for (i = 0; i < G_N_ELEMENTS (sampling_list); i++) {
+ GValue samp = G_VALUE_INIT;
+ g_value_init (&samp, G_TYPE_STRING);
+ g_value_set_string (&samp, sampling_list[i]);
+ gst_value_list_append_value (&sampling, &samp);
+ }
+
+ gst_caps_set_value (ret, "sampling", &sampling);
+ return ret;
+ }
+ return gst_caps_ref (caps);
+}
+
+static GstCaps *
+_fixup_src_caps (GstVaDisplay * display, GstCaps * caps)
+{
+ if (GST_VA_DISPLAY_IS_IMPLEMENTATION (display, INTEL_IHD)) {
+ GstCaps *ret;
+ GstStructure *s;
+ GstCapsFeatures *f;
+ guint i, len;
+
+ ret = gst_caps_copy (caps);
+
+ len = gst_caps_get_size (ret);
+ for (i = 0; i < len; i++) {
+ s = gst_caps_get_structure (ret, i);
+ f = gst_caps_get_features (ret, i);
+ if (gst_caps_features_is_equal (f,
+ GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY)) {
+ /* rgbp is not correctly mapped into memory */
+ guint i, siz;
+ GValue out = G_VALUE_INIT;
+ const GValue *in = gst_structure_get_value (s, "format");
+
+ siz = gst_value_list_get_size (in);
+ gst_value_list_init (&out, siz);
+ for (i = 0; i < siz; i++) {
+ const GValue *fmt = gst_value_list_get_value (in, i);
+ if (g_strcmp0 (g_value_get_string (fmt), "RGBP") != 0)
+ gst_value_list_append_value (&out, fmt);
+ }
+ gst_structure_set_value (s, "format", &out);
+ } else if (gst_caps_features_contains (f, GST_CAPS_FEATURE_MEMORY_DMABUF)) {
+ /* dmabuf exportation only handles NV12 */
+ gst_structure_set (s, "format", G_TYPE_STRING, "NV12", NULL);
+ }
+ }
+
+ return ret;
+ } else if (GST_VA_DISPLAY_IS_IMPLEMENTATION (display, INTEL_I965)) {
+ GstCaps *ret;
+ GstStructure *s;
+ guint i, len;
+
+ ret = gst_caps_copy (caps);
+
+ len = gst_caps_get_size (ret);
+ for (i = 0; i < len; i++) {
+ s = gst_caps_get_structure (ret, i);
+ /* only NV12 works in this nigthmare */
+ gst_structure_set (s, "format", G_TYPE_STRING, "NV12", NULL);
+ }
+
+ return ret;
+ }
+ return gst_caps_ref (caps);
+}
+
+gboolean
+gst_va_jpeg_dec_register (GstPlugin * plugin, GstVaDevice * device,
+ GstCaps * sink_caps, GstCaps * src_caps, guint rank)
+{
+ static GOnce debug_once = G_ONCE_INIT;
+ GType type;
+ GTypeInfo type_info = {
+ .class_size = sizeof (GstVaJpegDecClass),
+ .class_init = gst_va_jpeg_dec_class_init,
+ .instance_size = sizeof (GstVaJpegDec),
+ .instance_init = gst_va_jpeg_dec_init,
+ };
+ struct CData *cdata;
+ gboolean ret;
+ gchar *type_name, *feature_name;
+
+ g_return_val_if_fail (GST_IS_PLUGIN (plugin), FALSE);
+ g_return_val_if_fail (GST_IS_VA_DEVICE (device), FALSE);
+ g_return_val_if_fail (GST_IS_CAPS (sink_caps), FALSE);
+ g_return_val_if_fail (GST_IS_CAPS (src_caps), FALSE);
+
+ cdata = g_new (struct CData, 1);
+ cdata->description = NULL;
+ cdata->render_device_path = g_strdup (device->render_device_path);
+ cdata->sink_caps = _fixup_sink_caps (device->display, sink_caps);
+ cdata->src_caps = _fixup_src_caps (device->display, src_caps);
+
+ /* class data will be leaked if the element never gets instantiated */
+ GST_MINI_OBJECT_FLAG_SET (cdata->sink_caps,
+ GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
+ GST_MINI_OBJECT_FLAG_SET (src_caps, GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
+
+ type_info.class_data = cdata;
+
+ type_name = g_strdup ("GstVaJpegDec");
+ feature_name = g_strdup ("vajpegdec");
+
+ /* The first decoder to be registered should use a constant name,
+ * like vajpegdec, for any additional decoders, we create unique
+ * names, using inserting the render device name. */
+ if (g_type_from_name (type_name)) {
+ gchar *basename = g_path_get_basename (device->render_device_path);
+ g_free (type_name);
+ g_free (feature_name);
+ type_name = g_strdup_printf ("GstVa%sJpegDec", basename);
+ feature_name = g_strdup_printf ("va%sjpegdec", basename);
+ cdata->description = basename;
+
+ /* lower rank for non-first device */
+ if (rank > 0)
+ rank--;
+ }
+
+ g_once (&debug_once, _register_debug_category, NULL);
+
+ type = g_type_register_static (GST_TYPE_JPEG_DECODER,
+ type_name, &type_info, 0);
+
+ ret = gst_element_register (plugin, feature_name, rank, type);
+
+ g_free (type_name);
+ g_free (feature_name);
+
+ return ret;
+}
projects / platform / upstream / gstreamer.git / commitdiff