diff options
author | Seungha Yang <seungha@centricular.com> | 2020-10-30 20:37:44 +0900 |
---|---|---|
committer | Seungha Yang <seungha@centricular.com> | 2020-11-10 14:39:40 +0000 |
commit | 36ed24ac05c450ef41098e79cfefc13d80372ae8 (patch) | |
tree | 3feb579ec3edb626651f0207bd8072792c48c36f /sys | |
parent | 7c047da4b0da8e0b9bfbc92e3652d18bd0e6e405 (diff) | |
download | gstreamer-plugins-bad-36ed24ac05c450ef41098e79cfefc13d80372ae8.tar.gz |
nvcodec: Add VP8 stateless decoder element
Like other nvcodec stateless decoders, the rank of this new nvvp8sldec
element will be secondary for now.
Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/merge_requests/1738>
Diffstat (limited to 'sys')
-rw-r--r-- | sys/nvcodec/gstnvvp8dec.c | 569 | ||||
-rw-r--r-- | sys/nvcodec/gstnvvp8dec.h | 47 | ||||
-rw-r--r-- | sys/nvcodec/meson.build | 1 | ||||
-rw-r--r-- | sys/nvcodec/plugin.c | 17 |
4 files changed, 634 insertions, 0 deletions
diff --git a/sys/nvcodec/gstnvvp8dec.c b/sys/nvcodec/gstnvvp8dec.c new file mode 100644 index 000000000..b47298087 --- /dev/null +++ b/sys/nvcodec/gstnvvp8dec.c @@ -0,0 +1,569 @@ +/* GStreamer + * Copyright (C) 2020 Seungha Yang <seungha@centricular.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. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstnvvp8dec.h" +#include "gstcudautils.h" +#include "gstnvdecoder.h" + +#include <string.h> + +GST_DEBUG_CATEGORY_STATIC (gst_nv_vp8_dec_debug); +#define GST_CAT_DEFAULT gst_nv_vp8_dec_debug + +/* reference list 4 + 2 margin */ +#define NUM_OUTPUT_VIEW 6 + +struct _GstNvVp8Dec +{ + GstVp8Decoder parent; + + GstVideoCodecState *output_state; + + GstCudaContext *context; + CUstream cuda_stream; + GstNvDecoder *decoder; + CUVIDPICPARAMS params; + + guint width, height; + + /* For OpenGL interop. */ + GstObject *gl_display; + GstObject *gl_context; + GstObject *other_gl_context; + + GstNvDecoderOutputType output_type; +}; + +struct _GstNvVp8DecClass +{ + GstVp8DecoderClass parent_class; + guint cuda_device_id; +}; + +#define gst_nv_vp8_dec_parent_class parent_class + +/** + * GstNvVp8Dec: + * + * Since: 1.20 + */ +G_DEFINE_TYPE (GstNvVp8Dec, gst_nv_vp8_dec, GST_TYPE_VP8_DECODER); + +static void gst_nv_vp8_dec_set_context (GstElement * element, + GstContext * context); +static gboolean gst_nv_vp8_dec_open (GstVideoDecoder * decoder); +static gboolean gst_nv_vp8_dec_close (GstVideoDecoder * decoder); +static gboolean gst_nv_vp8_dec_negotiate (GstVideoDecoder * decoder); +static gboolean gst_nv_vp8_dec_decide_allocation (GstVideoDecoder * + decoder, GstQuery * query); +static gboolean gst_nv_vp8_dec_src_query (GstVideoDecoder * decoder, + GstQuery * query); + +/* GstVp8Decoder */ +static gboolean gst_nv_vp8_dec_new_sequence (GstVp8Decoder * decoder, + const GstVp8FrameHdr * frame_hdr); +static gboolean gst_nv_vp8_dec_new_picture (GstVp8Decoder * decoder, + GstVideoCodecFrame * frame, GstVp8Picture * picture); +static gboolean gst_nv_vp8_dec_decode_picture (GstVp8Decoder * decoder, + GstVp8Picture * picture, GstVp8Parser * parser); +static GstFlowReturn gst_nv_vp8_dec_output_picture (GstVp8Decoder * + decoder, GstVideoCodecFrame * frame, GstVp8Picture * picture); + +static void +gst_nv_vp8_dec_class_init (GstNvVp8DecClass * klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_CLASS (klass); + GstVp8DecoderClass *vp8decoder_class = GST_VP8_DECODER_CLASS (klass); + + element_class->set_context = GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_set_context); + + decoder_class->open = GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_open); + decoder_class->close = GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_close); + decoder_class->negotiate = GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_negotiate); + decoder_class->decide_allocation = + GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_decide_allocation); + decoder_class->src_query = GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_src_query); + + vp8decoder_class->new_sequence = + GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_new_sequence); + vp8decoder_class->new_picture = + GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_new_picture); + vp8decoder_class->decode_picture = + GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_decode_picture); + vp8decoder_class->output_picture = + GST_DEBUG_FUNCPTR (gst_nv_vp8_dec_output_picture); + + GST_DEBUG_CATEGORY_INIT (gst_nv_vp8_dec_debug, + "nvvp8dec", 0, "NVIDIA VP8 Decoder"); + + gst_type_mark_as_plugin_api (GST_TYPE_NV_VP8_DEC, 0); +} + +static void +gst_nv_vp8_dec_init (GstNvVp8Dec * self) +{ +} + +static void +gst_nv_vp8_dec_set_context (GstElement * element, GstContext * context) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (element); + GstNvVp8DecClass *klass = GST_NV_VP8_DEC_GET_CLASS (self); + + GST_DEBUG_OBJECT (self, "set context %s", + gst_context_get_context_type (context)); + + gst_nv_decoder_set_context (element, context, klass->cuda_device_id, + &self->context, &self->gl_display, &self->other_gl_context); + + GST_ELEMENT_CLASS (parent_class)->set_context (element, context); +} + +static gboolean +gst_nv_vp8_dec_open (GstVideoDecoder * decoder) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + GstNvVp8DecClass *klass = GST_NV_VP8_DEC_GET_CLASS (self); + + if (!gst_nv_decoder_ensure_element_data (GST_ELEMENT (self), + klass->cuda_device_id, &self->context, &self->cuda_stream, + &self->gl_display, &self->other_gl_context)) { + GST_ERROR_OBJECT (self, "Required element data is unavailable"); + return FALSE; + } + + return TRUE; +} + +static gboolean +gst_nv_vp8_dec_close (GstVideoDecoder * decoder) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + + g_clear_pointer (&self->output_state, gst_video_codec_state_unref); + gst_clear_object (&self->decoder); + + if (self->context && self->cuda_stream) { + if (gst_cuda_context_push (self->context)) { + gst_cuda_result (CuStreamDestroy (self->cuda_stream)); + gst_cuda_context_pop (NULL); + } + } + + gst_clear_object (&self->gl_context); + gst_clear_object (&self->other_gl_context); + gst_clear_object (&self->gl_display); + gst_clear_object (&self->context); + self->cuda_stream = NULL; + + return TRUE; +} + +static gboolean +gst_nv_vp8_dec_negotiate (GstVideoDecoder * decoder) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + GstVp8Decoder *vp8dec = GST_VP8_DECODER (decoder); + + GST_DEBUG_OBJECT (self, "negotiate"); + + gst_nv_decoder_negotiate (decoder, vp8dec->input_state, GST_VIDEO_FORMAT_NV12, + self->width, self->height, self->gl_display, self->other_gl_context, + &self->gl_context, &self->output_state, &self->output_type); + + /* TODO: add support D3D11 memory */ + + return GST_VIDEO_DECODER_CLASS (parent_class)->negotiate (decoder); +} + +static gboolean +gst_nv_vp8_dec_decide_allocation (GstVideoDecoder * decoder, GstQuery * query) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + + gst_nv_decoder_decide_allocation (self->decoder, decoder, query, + self->gl_context, self->output_type); + + return GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation + (decoder, query); +} + +static gboolean +gst_nv_vp8_dec_src_query (GstVideoDecoder * decoder, GstQuery * query) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_CONTEXT: + if (gst_nv_decoder_handle_context_query (GST_ELEMENT (self), query, + self->context, self->gl_display, self->gl_context, + self->other_gl_context)) { + return TRUE; + } + break; + default: + break; + } + + return GST_VIDEO_DECODER_CLASS (parent_class)->src_query (decoder, query); +} + +static gboolean +gst_nv_vp8_dec_new_sequence (GstVp8Decoder * decoder, + const GstVp8FrameHdr * frame_hdr) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + gboolean modified = FALSE; + + GST_LOG_OBJECT (self, "new sequence"); + + if (self->width != frame_hdr->width || self->height != frame_hdr->height) { + if (self->decoder) { + GST_INFO_OBJECT (self, "resolution changed %dx%d -> %dx%d", + self->width, self->height, frame_hdr->width, frame_hdr->height); + } + + self->width = frame_hdr->width; + self->height = frame_hdr->height; + + modified = TRUE; + } + + if (modified || !self->decoder) { + GstVideoInfo info; + + gst_clear_object (&self->decoder); + + gst_video_info_set_format (&info, + GST_VIDEO_FORMAT_NV12, self->width, self->height); + + self->decoder = gst_nv_decoder_new (self->context, cudaVideoCodec_VP8, + &info, NUM_OUTPUT_VIEW); + + if (!self->decoder) { + GST_ERROR_OBJECT (self, "Failed to create decoder"); + return FALSE; + } + + if (!gst_video_decoder_negotiate (GST_VIDEO_DECODER (self))) { + GST_ERROR_OBJECT (self, "Failed to negotiate with downstream"); + return FALSE; + } + + memset (&self->params, 0, sizeof (CUVIDPICPARAMS)); + + self->params.PicWidthInMbs = GST_ROUND_UP_16 (self->width) >> 4; + self->params.FrameHeightInMbs = GST_ROUND_UP_16 (self->height) >> 4; + + self->params.CodecSpecific.vp8.width = self->width; + self->params.CodecSpecific.vp8.height = self->height; + } + + return TRUE; +} + +static gboolean +gst_nv_vp8_dec_new_picture (GstVp8Decoder * decoder, + GstVideoCodecFrame * frame, GstVp8Picture * picture) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + GstNvDecoderFrame *nv_frame; + + nv_frame = gst_nv_decoder_new_frame (self->decoder); + if (!nv_frame) { + GST_ERROR_OBJECT (self, "No available decoder frame"); + return FALSE; + } + + GST_LOG_OBJECT (self, + "New decoder frame %p (index %d)", nv_frame, nv_frame->index); + + gst_vp8_picture_set_user_data (picture, + nv_frame, (GDestroyNotify) gst_nv_decoder_frame_free); + + return TRUE; +} + +static GstNvDecoderFrame * +gst_nv_vp8_dec_get_decoder_frame_from_picture (GstNvVp8Dec * self, + GstVp8Picture * picture) +{ + GstNvDecoderFrame *frame; + + frame = (GstNvDecoderFrame *) gst_vp8_picture_get_user_data (picture); + + if (!frame) + GST_DEBUG_OBJECT (self, "current picture does not have decoder frame"); + + return frame; +} + +static gboolean +gst_nv_vp8_dec_decode_picture (GstVp8Decoder * decoder, + GstVp8Picture * picture, GstVp8Parser * parser) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + GstVp8FrameHdr *frame_hdr = &picture->frame_hdr; + GstNvDecoderFrame *frame; + GstNvDecoderFrame *other_frame; + guint offset = 0; + + GST_LOG_OBJECT (self, "Decode picture, size %" G_GSIZE_FORMAT, picture->size); + + frame = gst_nv_vp8_dec_get_decoder_frame_from_picture (self, picture); + if (!frame) { + GST_ERROR_OBJECT (self, "Decoder frame is unavailable"); + return FALSE; + } + + self->params.nBitstreamDataLen = picture->size; + self->params.pBitstreamData = picture->data; + self->params.nNumSlices = 1; + self->params.pSliceDataOffsets = &offset; + + self->params.CurrPicIdx = frame->index; + + self->params.CodecSpecific.vp8.first_partition_size = + frame_hdr->first_part_size; + + if (decoder->alt_ref_picture) { + other_frame = + gst_nv_vp8_dec_get_decoder_frame_from_picture (self, + decoder->alt_ref_picture); + if (!other_frame) { + GST_ERROR_OBJECT (self, "Couldn't get decoder frame for AltRef"); + return FALSE; + } + + self->params.CodecSpecific.vp8.AltRefIdx = other_frame->index; + } else { + self->params.CodecSpecific.vp8.AltRefIdx = 0xff; + } + + if (decoder->golden_ref_picture) { + other_frame = + gst_nv_vp8_dec_get_decoder_frame_from_picture (self, + decoder->golden_ref_picture); + if (!other_frame) { + GST_ERROR_OBJECT (self, "Couldn't get decoder frame for GoldenRef"); + return FALSE; + } + + self->params.CodecSpecific.vp8.GoldenRefIdx = other_frame->index; + } else { + self->params.CodecSpecific.vp8.GoldenRefIdx = 0xff; + } + + if (decoder->last_picture) { + other_frame = + gst_nv_vp8_dec_get_decoder_frame_from_picture (self, + decoder->last_picture); + if (!other_frame) { + GST_ERROR_OBJECT (self, "Couldn't get decoder frame for LastRef"); + return FALSE; + } + + self->params.CodecSpecific.vp8.LastRefIdx = other_frame->index; + } else { + self->params.CodecSpecific.vp8.LastRefIdx = 0xff; + } + + self->params.CodecSpecific.vp8.vp8_frame_tag.frame_type = + frame_hdr->key_frame ? 0 : 1; + self->params.CodecSpecific.vp8.vp8_frame_tag.version = frame_hdr->version; + self->params.CodecSpecific.vp8.vp8_frame_tag.show_frame = + frame_hdr->show_frame; + self->params.CodecSpecific.vp8.vp8_frame_tag.update_mb_segmentation_data = + parser->segmentation.segmentation_enabled ? + parser->segmentation.update_segment_feature_data : 0; + + return gst_nv_decoder_decode_picture (self->decoder, &self->params); +} + +static GstFlowReturn +gst_nv_vp8_dec_output_picture (GstVp8Decoder * decoder, + GstVideoCodecFrame * frame, GstVp8Picture * picture) +{ + GstNvVp8Dec *self = GST_NV_VP8_DEC (decoder); + GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder); + GstNvDecoderFrame *decoder_frame; + gboolean ret G_GNUC_UNUSED = FALSE; + + GST_LOG_OBJECT (self, "Outputting picture %p", picture); + + decoder_frame = (GstNvDecoderFrame *) gst_vp8_picture_get_user_data (picture); + if (!decoder_frame) { + GST_ERROR_OBJECT (self, "No decoder frame in picture %p", picture); + goto error; + } + + frame->output_buffer = gst_video_decoder_allocate_output_buffer (vdec); + if (!frame->output_buffer) { + GST_ERROR_OBJECT (self, "Couldn't allocate output buffer"); + goto error; + } + + if (self->output_type == GST_NV_DECOCER_OUTPUT_TYPE_GL) { + ret = gst_nv_decoder_finish_frame (self->decoder, + GST_NV_DECOCER_OUTPUT_TYPE_GL, self->gl_context, + decoder_frame, frame->output_buffer); + + /* FIXME: This is the case where OpenGL context of downstream glbufferpool + * belongs to non-nvidia (or different device). + * There should be enhancement to ensure nvdec has compatible OpenGL context + */ + if (!ret) { + GST_WARNING_OBJECT (self, + "Couldn't copy frame to GL memory, fallback to system memory"); + self->output_type = GST_NV_DECOCER_OUTPUT_TYPE_SYSTEM; + } + } + + if (!ret) { + if (!gst_nv_decoder_finish_frame (self->decoder, + self->output_type, NULL, decoder_frame, frame->output_buffer)) { + GST_ERROR_OBJECT (self, "Failed to finish frame"); + goto error; + } + } + + gst_vp8_picture_unref (picture); + + return gst_video_decoder_finish_frame (vdec, frame); + +error: + gst_video_decoder_drop_frame (vdec, frame); + gst_vp8_picture_unref (picture); + + return GST_FLOW_ERROR; +} + +typedef struct +{ + GstCaps *sink_caps; + GstCaps *src_caps; + guint cuda_device_id; + gboolean is_default; +} GstNvVp8DecClassData; + +static void +gst_nv_vp8_dec_subclass_init (gpointer klass, GstNvVp8DecClassData * cdata) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + GstNvVp8DecClass *nvdec_class = (GstNvVp8DecClass *) (klass); + gchar *long_name; + + if (cdata->is_default) { + long_name = g_strdup_printf ("NVDEC VP8 Stateless Decoder"); + } else { + long_name = g_strdup_printf ("NVDEC VP8 Stateless Decoder with device %d", + cdata->cuda_device_id); + } + + gst_element_class_set_metadata (element_class, long_name, + "Codec/Decoder/Video/Hardware", + "NVIDIA VP8 video decoder", "Seungha Yang <seungha@centricular.com>"); + g_free (long_name); + + gst_element_class_add_pad_template (element_class, + gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, + cdata->sink_caps)); + gst_element_class_add_pad_template (element_class, + gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, + cdata->src_caps)); + + nvdec_class->cuda_device_id = cdata->cuda_device_id; + + gst_caps_unref (cdata->sink_caps); + gst_caps_unref (cdata->src_caps); + g_free (cdata); +} + +void +gst_nv_vp8_dec_register (GstPlugin * plugin, guint device_id, guint rank, + GstCaps * sink_caps, GstCaps * src_caps, gboolean is_primary) +{ + GTypeQuery type_query; + GTypeInfo type_info = { 0, }; + GType subtype; + gchar *type_name; + gchar *feature_name; + GstNvVp8DecClassData *cdata; + gboolean is_default = TRUE; + + /** + * element-nvvp8sldec: + * + * Since: 1.20 + */ + + cdata = g_new0 (GstNvVp8DecClassData, 1); + cdata->sink_caps = gst_caps_ref (sink_caps); + cdata->src_caps = gst_caps_ref (src_caps); + cdata->cuda_device_id = device_id; + + g_type_query (GST_TYPE_NV_VP8_DEC, &type_query); + memset (&type_info, 0, sizeof (type_info)); + type_info.class_size = type_query.class_size; + type_info.instance_size = type_query.instance_size; + type_info.class_init = (GClassInitFunc) gst_nv_vp8_dec_subclass_init; + type_info.class_data = cdata; + + if (is_primary) { + type_name = g_strdup ("GstNvVP8StatelessPrimaryDec"); + feature_name = g_strdup ("nvvp8dec"); + } else { + type_name = g_strdup ("GstNvVP8StatelessDec"); + feature_name = g_strdup ("nvvp8sldec"); + } + + if (g_type_from_name (type_name) != 0) { + g_free (type_name); + g_free (feature_name); + if (is_primary) { + type_name = + g_strdup_printf ("GstNvVP8StatelessPrimaryDevice%dDec", device_id); + feature_name = g_strdup_printf ("nvvp8device%ddec", device_id); + } else { + type_name = g_strdup_printf ("GstNvVP8StatelessDevice%dDec", device_id); + feature_name = g_strdup_printf ("nvvp8sldevice%ddec", device_id); + } + + is_default = FALSE; + } + + cdata->is_default = is_default; + subtype = g_type_register_static (GST_TYPE_NV_VP8_DEC, + type_name, &type_info, 0); + + /* make lower rank than default device */ + if (rank > 0 && !is_default) + rank--; + + if (!gst_element_register (plugin, feature_name, rank, subtype)) + GST_WARNING ("Failed to register plugin '%s'", type_name); + + g_free (type_name); + g_free (feature_name); +} diff --git a/sys/nvcodec/gstnvvp8dec.h b/sys/nvcodec/gstnvvp8dec.h new file mode 100644 index 000000000..df55f2e0c --- /dev/null +++ b/sys/nvcodec/gstnvvp8dec.h @@ -0,0 +1,47 @@ +/* GStreamer + * Copyright (C) 2020 Seungha Yang <seungha@centricular.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. + */ + +#ifndef __GST_NV_VP8_DEC_H__ +#define __GST_NV_VP8_DEC_H__ + +#include <gst/gst.h> +#include <gst/codecs/gstvp8decoder.h> + +G_BEGIN_DECLS + +#define GST_TYPE_NV_VP8_DEC (gst_nv_vp8_dec_get_type()) +#define GST_NV_VP8_DEC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_NV_VP8_DEC, GstNvVp8Dec)) +#define GST_NV_VP8_DEC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_NV_VP8_DEC, GstNvVp8DecClass)) +#define GST_NV_VP8_DEC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_NV_VP8_DEC, GstNvVp8DecClass)) + +typedef struct _GstNvVp8Dec GstNvVp8Dec; +typedef struct _GstNvVp8DecClass GstNvVp8DecClass; + +GType gst_nv_vp8_dec_get_type (void); + +void gst_nv_vp8_dec_register (GstPlugin * plugin, + guint device_id, + guint rank, + GstCaps * sink_caps, + GstCaps * src_caps, + gboolean is_primary); + +G_END_DECLS + +#endif /* __GST_NV_VP8_DEC_H__ */ diff --git a/sys/nvcodec/meson.build b/sys/nvcodec/meson.build index 7595aeff0..f27308f2b 100644 --- a/sys/nvcodec/meson.build +++ b/sys/nvcodec/meson.build @@ -24,6 +24,7 @@ nvcodec_sources = [ 'gstcudabasefilter.c', 'gstcudaconvert.c', 'gstcudascale.c', + 'gstnvvp8dec.c', ] if get_option('nvcodec').disabled() diff --git a/sys/nvcodec/plugin.c b/sys/nvcodec/plugin.c index 53fe15da2..e4c95f6fb 100644 --- a/sys/nvcodec/plugin.c +++ b/sys/nvcodec/plugin.c @@ -33,6 +33,7 @@ #include "gstnvenc.h" #include "gstnvh264dec.h" #include "gstnvh265dec.h" +#include "gstnvvp8dec.h" #include "gstnvdecoder.h" #include "gstcudadownload.h" #include "gstcudaupload.h" @@ -59,6 +60,7 @@ plugin_init (GstPlugin * plugin) const gchar *env; gboolean use_h264_sl_dec = FALSE; gboolean use_h265_sl_dec = FALSE; + gboolean use_vp8_sl_dec = FALSE; GST_DEBUG_CATEGORY_INIT (gst_nvcodec_debug, "nvcodec", 0, "nvcodec"); GST_DEBUG_CATEGORY_INIT (gst_nvdec_debug, "nvdec", 0, "nvdec"); @@ -111,6 +113,9 @@ plugin_init (GstPlugin * plugin) } else if (g_ascii_strcasecmp (*iter, "h265") == 0) { GST_INFO ("Found %s in GST_USE_NV_STATELESS_CODEC environment", *iter); use_h265_sl_dec = TRUE; + } else if (g_ascii_strcasecmp (*iter, "vp8") == 0) { + GST_INFO ("Found %s in GST_USE_NV_STATELESS_CODEC environment", *iter); + use_vp8_sl_dec = TRUE; } } @@ -178,6 +183,18 @@ plugin_init (GstPlugin * plugin) i, GST_RANK_PRIMARY, sink_template, src_template, TRUE); } break; + case cudaVideoCodec_VP8: + gst_nv_vp8_dec_register (plugin, + i, GST_RANK_SECONDARY, sink_template, src_template, FALSE); + if (use_vp8_sl_dec) { + GST_INFO + ("Skipping registration of CUVID parser based nvhvp8dec element"); + register_cuviddec = FALSE; + + gst_nv_vp8_dec_register (plugin, + i, GST_RANK_PRIMARY, sink_template, src_template, TRUE); + } + break; default: break; } |