va: Add vajpegdec element.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1575>

subprojects/gst-plugins-bad/sys/va/gstvabasedec.h

@@ -21,15 +21,16 @@
 
 #pragma once
 
+#include <gst/codecs/gstav1decoder.h>
 #include <gst/codecs/gsth264decoder.h>
 #include <gst/codecs/gsth265decoder.h>
 #include <gst/codecs/gstmpeg2decoder.h>
 #include <gst/codecs/gstvp8decoder.h>
 #include <gst/codecs/gstvp9decoder.h>
-#include <gst/codecs/gstav1decoder.h>
 
-#include "gstvadevice.h"
+#include "gstjpegdecoder.h"
 #include "gstvadecoder.h"
+#include "gstvadevice.h"
 #include "gstvaprofile.h"
 
 G_BEGIN_DECLS
@@ -57,6 +58,7 @@ struct _GstVaBaseDec
     GstVp8Decoder vp8;
     GstVp9Decoder vp9;
     GstAV1Decoder av1;
+    GstJpegDecoder jpeg;
   } parent;
 
   GstDebugCategory *debug_category;

subprojects/gst-plugins-bad/sys/va/gstvajpegdec.c

@@ -0,0 +1,625 @@
+/* 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;
+}

subprojects/gst-plugins-bad/sys/va/gstvajpegdec.h

@@ -0,0 +1,33 @@
+/* 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 the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "gstvadevice.h"
+
+G_BEGIN_DECLS
+
+gboolean              gst_va_jpeg_dec_register            (GstPlugin * plugin,
+                                                           GstVaDevice * device,
+                                                           GstCaps * sink_caps,
+                                                           GstCaps * src_caps,
+                                                           guint rank);
+
+G_END_DECLS

subprojects/gst-plugins-bad/sys/va/gstvaprofile.c

@@ -61,7 +61,7 @@ static const struct ProfileMap
   P (H263, Baseline, "baseline", "video/x-h263",
       "variant = (string) itu, h263version = (string) h263, "
       "profile = (string) baseline"),
-  P (JPEG, Baseline, "", "image/jpeg", NULL),
+  P (JPEG, Baseline, "", "image/jpeg", "sof-marker = (int) 0"),
   P (H264, ConstrainedBaseline, "constrained-baseline", "video/x-h264",
       "profile = (string) { constrained-baseline, baseline }"),
   P (VP8, Version0_3, "", "video/x-vp8", NULL),

subprojects/gst-plugins-bad/sys/va/meson.build

@@ -15,6 +15,7 @@ va_sources = [
   'gstvah264dec.c',
   'gstvah264enc.c',
   'gstvah265dec.c',
+  'gstvajpegdec.c',
   'gstvampeg2dec.c',
   'gstvaprofile.c',
   'gstvavp8dec.c',

subprojects/gst-plugins-bad/sys/va/plugin.c

@@ -36,6 +36,7 @@
 #include "gstvah264dec.h"
 #include "gstvah264enc.h"
 #include "gstvah265dec.h"
+#include "gstvajpegdec.h"
 #include "gstvampeg2dec.h"
 #include "gstvaprofile.h"
 #include "gstvavp8dec.h"
@@ -142,6 +143,13 @@ plugin_register_decoders (GstPlugin * plugin, GstVaDevice * device,
         }
         break;
 #endif
+      case JPEG:
+        if (!gst_va_jpeg_dec_register (plugin, device, sinkcaps, srccaps,
+                GST_RANK_NONE)) {
+          GST_WARNING ("Failed to register JPEG decoder: %s",
+              device->render_device_path);
+        }
+        break;
       default:
         GST_DEBUG ("No decoder implementation for %" GST_FOURCC_FORMAT,
             GST_FOURCC_ARGS (codec));