Commit 63a8fc50 authored by Víctor Manuel Jáquez Leal's avatar Víctor Manuel Jáquez Leal Committed by GStreamer Marge Bot
Browse files

va: Add vajpegdec element.

Part-of: <gstreamer/gstreamer!1575>
parent ec55017a
......@@ -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;
......
/* 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,