From 1c583fd27b8625482d71f6af2acd60a9e8ac53bb Mon Sep 17 00:00:00 2001 From: Sean DuBois Date: Tue, 27 Jun 2017 22:50:41 +0000 Subject: [PATCH] Add aom plugin with av1enc and av1dec element https://bugzilla.gnome.org/show_bug.cgi?id=784160 --- configure.ac | 8 + ext/Makefile.am | 8 + ext/aom/Makefile.am | 15 ++ ext/aom/gstaom.c | 50 +++++++ ext/aom/gstaom.h | 24 +++ ext/aom/gstav1dec.c | 348 +++++++++++++++++++++++++++++++++++++++++++ ext/aom/gstav1dec.h | 70 +++++++++ ext/aom/gstav1enc.c | 350 ++++++++++++++++++++++++++++++++++++++++++++ ext/aom/gstav1enc.h | 69 +++++++++ ext/aom/meson.build | 11 ++ ext/meson.build | 1 + 11 files changed, 954 insertions(+) create mode 100644 ext/aom/Makefile.am create mode 100644 ext/aom/gstaom.c create mode 100644 ext/aom/gstaom.h create mode 100644 ext/aom/gstav1dec.c create mode 100644 ext/aom/gstav1dec.h create mode 100644 ext/aom/gstav1enc.c create mode 100644 ext/aom/gstav1enc.h create mode 100644 ext/aom/meson.build diff --git a/configure.ac b/configure.ac index f60701c13f..9a401e8015 100644 --- a/configure.ac +++ b/configure.ac @@ -2131,6 +2131,12 @@ AG_GST_CHECK_FEATURE(ASSRENDER, [ASS/SSA renderer], assrender, [ AC_SUBST(ASSRENDER_CFLAGS) AC_SUBST(ASSRENDER_LIBS) +dnl *** AOM *** +translit(dnm, m, l) AM_CONDITIONAL(USE_AOM, true) +AG_GST_CHECK_FEATURE(AOM, [AV1 encoder/decoder], aom, [ + AG_GST_PKG_CHECK_MODULES(AOM, aom) +]) + dnl *** vo-amrwbenc *** translit(dnm, m, l) AM_CONDITIONAL(USE_VOAMRWBENC, true) AG_GST_CHECK_FEATURE(VOAMRWBENC, [vo-amrwbenc library], vo-amrwbenc, [ @@ -3435,6 +3441,7 @@ dnl not building plugins with external dependencies, dnl but we still need to set the conditionals AM_CONDITIONAL(USE_ASSRENDER, false) +AM_CONDITIONAL(USE_AOM, false) AM_CONDITIONAL(USE_VOAMRWBENC, false) AM_CONDITIONAL(USE_VOAACENC, false) AM_CONDITIONAL(USE_BS2B, false) @@ -3760,6 +3767,7 @@ tests/icles/Makefile ext/voamrwbenc/Makefile ext/voaacenc/Makefile ext/assrender/Makefile +ext/aom/Makefile ext/bs2b/Makefile ext/bz2/Makefile ext/chromaprint/Makefile diff --git a/ext/Makefile.am b/ext/Makefile.am index 0c35ff53e5..e4e0db7d68 100644 --- a/ext/Makefile.am +++ b/ext/Makefile.am @@ -4,6 +4,12 @@ else ASSRENDER_DIR = endif +if USE_AOM +AOM_DIR= aom +else +AOM_DIR= +endif + if USE_VOAMRWBENC VOAMRWBENC_DIR = voamrwbenc else @@ -409,6 +415,7 @@ endif SUBDIRS=\ $(VOAACENC_DIR) \ $(ASSRENDER_DIR) \ + $(AOM_DIR) \ $(VOAMRWBENC_DIR) \ $(AUDIOFILE_DIR) \ $(BS2B_DIR) \ @@ -479,6 +486,7 @@ SUBDIRS=\ DIST_SUBDIRS = \ assrender \ + aom \ bs2b \ bz2 \ colormanagement \ diff --git a/ext/aom/Makefile.am b/ext/aom/Makefile.am new file mode 100644 index 0000000000..c28decd376 --- /dev/null +++ b/ext/aom/Makefile.am @@ -0,0 +1,15 @@ +plugin_LTLIBRARIES = libgstaom.la + +libgstaom_la_SOURCES = \ + gstaom.c \ + gstav1enc.c \ + gstav1dec.c + +libgstaom_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS) $(AOM_CFLAGS) +libgstaom_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) $(GST_BASE_LIBS) $(GST_LIBS) -lgstvideo-$(GST_API_VERSION) $(AOM_LIBS) +libgstaom_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) + +noinst_HEADERS = \ + gstaom.h \ + gstav1dec.h \ + gstav1enc.h diff --git a/ext/aom/gstaom.c b/ext/aom/gstaom.c new file mode 100644 index 0000000000..5066105756 --- /dev/null +++ b/ext/aom/gstaom.c @@ -0,0 +1,50 @@ +/* GStreamer + * Copyright (C) <2017> Sean DuBois + * + * 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 +#endif + +#include + +#include "gstaom.h" +#include "gstav1enc.h" +#include "gstav1dec.h" + +static gboolean +plugin_init (GstPlugin * plugin) +{ + + if (!gst_element_register (plugin, "av1enc", GST_RANK_PRIMARY, + GST_TYPE_AV1_ENC)) { + return FALSE; + } + + if (!gst_element_register (plugin, "av1dec", GST_RANK_PRIMARY, + GST_TYPE_AV1_DEC)) { + return FALSE; + } + + return TRUE; +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + aom, + "AOM plugin library", + plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) diff --git a/ext/aom/gstaom.h b/ext/aom/gstaom.h new file mode 100644 index 0000000000..e1147d46bc --- /dev/null +++ b/ext/aom/gstaom.h @@ -0,0 +1,24 @@ +/* GStreamer + * Copyright (C) <2017> Sean DuBois + * + * 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_AOM_H__ +#define __GST_AOM_H__ + +#endif /* __GST_AOM_H__ */ diff --git a/ext/aom/gstav1dec.c b/ext/aom/gstav1dec.c new file mode 100644 index 0000000000..d5b93548bf --- /dev/null +++ b/ext/aom/gstav1dec.c @@ -0,0 +1,348 @@ +/* GStreamer + * Copyright (C) <2017> Sean DuBois + * + * 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. + */ +/** + * SECTION:element-av1dec + * + * AV1 Decoder. + * + * + * Example launch line + * |[ + * gst-launch-1.0 -v filesrc location=videotestsrc.webm ! matroskademux ! av1dec ! videoconvert ! videoscale ! autovideosink + * ]| + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include "gstav1dec.h" + +enum +{ + PROP_0, +}; + +static GstStaticPadTemplate gst_av1_dec_sink_pad_template = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-av1") + ); + +static GstStaticPadTemplate gst_av1_dec_src_pad_template = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-raw, " + "format = (string) \"I420\", " + "framerate = (fraction) [0, MAX], " + "width = (int) [ 4, MAX ], " "height = (int) [ 4, MAX ]") + ); + +GST_DEBUG_CATEGORY_STATIC (av1_dec_debug); +#define GST_CAT_DEFAULT av1_dec_debug + +static void gst_av1_dec_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_av1_dec_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static gboolean gst_av1_dec_start (GstVideoDecoder * dec); +static gboolean gst_av1_dec_stop (GstVideoDecoder * dec); +static gboolean gst_av1_dec_set_format (GstVideoDecoder * dec, + GstVideoCodecState * state); +static GstFlowReturn +gst_av1_dec_handle_frame (GstVideoDecoder * decoder, + GstVideoCodecFrame * frame); + +static void gst_av1_dec_image_to_buffer (GstAV1Dec * dec, + const aom_image_t * img, GstBuffer * buffer); +static GstFlowReturn gst_av1_dec_open_codec (GstAV1Dec * av1dec, + GstVideoCodecFrame * frame); + +#define gst_av1_dec_parent_class parent_class +G_DEFINE_TYPE (GstAV1Dec, gst_av1_dec, GST_TYPE_VIDEO_DECODER); + +static void +gst_av1_dec_class_init (GstAV1DecClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *element_class; + GstVideoDecoderClass *vdec_class; + + gobject_class = (GObjectClass *) klass; + element_class = (GstElementClass *) klass; + vdec_class = (GstVideoDecoderClass *) klass; + + + parent_class = g_type_class_peek_parent (klass); + + gobject_class->set_property = gst_av1_dec_set_property; + gobject_class->get_property = gst_av1_dec_get_property; + + gst_element_class_add_static_pad_template (element_class, + &gst_av1_dec_src_pad_template); + gst_element_class_add_static_pad_template (element_class, + &gst_av1_dec_sink_pad_template); + gst_element_class_set_static_metadata (element_class, "AV1 Decoder", + "Codec/Decoder/Video", "Decode AV1 video streams", + "Sean DuBois "); + + vdec_class->start = GST_DEBUG_FUNCPTR (gst_av1_dec_start); + vdec_class->stop = GST_DEBUG_FUNCPTR (gst_av1_dec_stop); + vdec_class->set_format = GST_DEBUG_FUNCPTR (gst_av1_dec_set_format); + vdec_class->handle_frame = GST_DEBUG_FUNCPTR (gst_av1_dec_handle_frame); + + klass->codec_algo = &aom_codec_av1_dx_algo; + GST_DEBUG_CATEGORY_INIT (av1_dec_debug, "av1dec", 0, "AV1 decoding element"); +} + +static void +gst_av1_dec_init (GstAV1Dec * av1dec) +{ + GstVideoDecoder *dec = (GstVideoDecoder *) av1dec; + + GST_DEBUG_OBJECT (dec, "gst_av1_dec_init"); + gst_video_decoder_set_packetized (dec, TRUE); + gst_video_decoder_set_needs_format (dec, TRUE); + gst_video_decoder_set_use_default_pad_acceptcaps (dec, TRUE); + GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_DECODER_SINK_PAD (dec)); +} + +static void +gst_av1_dec_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + switch (prop_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_av1_dec_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + switch (prop_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static gboolean +gst_av1_dec_start (GstVideoDecoder * dec) +{ + GstAV1Dec *av1dec = (GstAV1Dec *) dec; + + av1dec->decoder_inited = FALSE; + av1dec->output_state = NULL; + av1dec->input_state = NULL; + + return TRUE; +} + +static gboolean +gst_av1_dec_stop (GstVideoDecoder * dec) +{ + GstAV1Dec *av1dec = (GstAV1Dec *) dec; + + if (av1dec->output_state) { + gst_video_codec_state_unref (av1dec->output_state); + av1dec->output_state = NULL; + } + + if (av1dec->input_state) { + gst_video_codec_state_unref (av1dec->input_state); + av1dec->input_state = NULL; + } + + return TRUE; +} + +static gboolean +gst_av1_dec_set_format (GstVideoDecoder * dec, GstVideoCodecState * state) +{ + GstAV1Dec *av1dec = (GstAV1Dec *) dec; + + if (av1dec->decoder_inited) { + aom_codec_destroy (&av1dec->decoder); + } + av1dec->decoder_inited = FALSE; + + if (av1dec->output_state) { + gst_video_codec_state_unref (av1dec->output_state); + av1dec->output_state = NULL; + } + + if (av1dec->input_state) { + gst_video_codec_state_unref (av1dec->input_state); + } + + av1dec->input_state = gst_video_codec_state_ref (state); + + return TRUE; +} + +static GstFlowReturn +gst_av1_dec_open_codec (GstAV1Dec * av1dec, GstVideoCodecFrame * frame) +{ + aom_codec_err_t status; + GstAV1DecClass *av1class = GST_AV1_DEC_GET_CLASS (av1dec); + + status = aom_codec_dec_init (&av1dec->decoder, av1class->codec_algo, NULL, 0); + if (status != AOM_CODEC_OK) { + GST_ELEMENT_ERROR (av1dec, LIBRARY, INIT, + ("Failed to initialize AOM decoder"), ("%s", "")); + return GST_FLOW_ERROR; + } + + av1dec->decoder_inited = TRUE; + return GST_FLOW_OK; +} + +static void +gst_av1_dec_handle_resolution_change (GstAV1Dec * av1dec, aom_image_t * img, + GstVideoFormat fmt) +{ + if (!av1dec->output_state || + av1dec->output_state->info.finfo->format != fmt || + av1dec->output_state->info.width != img->d_w || + av1dec->output_state->info.height != img->d_h) { + + if (av1dec->output_state) + gst_video_codec_state_unref (av1dec->output_state); + + av1dec->output_state = + gst_video_decoder_set_output_state (GST_VIDEO_DECODER (av1dec), + fmt, img->d_w, img->d_h, av1dec->input_state); + gst_video_decoder_negotiate (GST_VIDEO_DECODER (av1dec)); + } + + +} + +static void +gst_av1_dec_image_to_buffer (GstAV1Dec * dec, const aom_image_t * img, + GstBuffer * buffer) +{ + int deststride, srcstride, height, width, line, comp; + guint8 *dest, *src; + GstVideoFrame frame; + GstVideoInfo *info = &dec->output_state->info; + + if (!gst_video_frame_map (&frame, info, buffer, GST_MAP_WRITE)) { + GST_ERROR_OBJECT (dec, "Could not map video buffer"); + return; + } + + for (comp = 0; comp < 3; comp++) { + dest = GST_VIDEO_FRAME_COMP_DATA (&frame, comp); + src = img->planes[comp]; + width = GST_VIDEO_FRAME_COMP_WIDTH (&frame, comp) + * GST_VIDEO_FRAME_COMP_PSTRIDE (&frame, comp); + height = GST_VIDEO_FRAME_COMP_HEIGHT (&frame, comp); + deststride = GST_VIDEO_FRAME_COMP_STRIDE (&frame, comp); + srcstride = img->stride[comp]; + + if (srcstride == deststride) { + GST_TRACE_OBJECT (dec, "Stride matches. Comp %d: %d, copying full plane", + comp, srcstride); + memcpy (dest, src, srcstride * height); + } else { + GST_TRACE_OBJECT (dec, "Stride mismatch. Comp %d: %d != %d, copying " + "line by line.", comp, srcstride, deststride); + for (line = 0; line < height; line++) { + memcpy (dest, src, width); + dest += deststride; + src += srcstride; + } + } + } + + gst_video_frame_unmap (&frame); +} + +static GstFlowReturn +gst_av1_dec_handle_frame (GstVideoDecoder * dec, GstVideoCodecFrame * frame) +{ + GstAV1Dec *av1dec = (GstAV1Dec *) dec; + GstFlowReturn ret; + GstMapInfo minfo; + aom_codec_err_t status; + aom_image_t *img; + aom_codec_iter_t iter = NULL; + + if (!av1dec->decoder_inited) { + ret = gst_av1_dec_open_codec (av1dec, frame); + if (ret == GST_FLOW_CUSTOM_SUCCESS_1) { + gst_video_decoder_drop_frame (dec, frame); + return GST_FLOW_OK; + } else if (ret != GST_FLOW_OK) { + gst_video_codec_frame_unref (frame); + return ret; + } + } + + if (!gst_buffer_map (frame->input_buffer, &minfo, GST_MAP_READ)) { + GST_ERROR_OBJECT (dec, "Failed to map input buffer"); + gst_video_codec_frame_unref (frame); + return GST_FLOW_ERROR; + } + + status = aom_codec_decode (&av1dec->decoder, minfo.data, minfo.size, NULL, 0); + + gst_buffer_unmap (frame->input_buffer, &minfo); + + if (status) { + GST_ELEMENT_ERROR (av1dec, LIBRARY, INIT, + ("Failed to decode frame"), ("%s", "")); + gst_video_codec_frame_unref (frame); + return ret; + } + + img = aom_codec_get_frame (&av1dec->decoder, &iter); + if (img) { + gst_av1_dec_handle_resolution_change (av1dec, img, GST_VIDEO_FORMAT_I420); + + ret = gst_video_decoder_allocate_output_frame (dec, frame); + if (ret == GST_FLOW_OK) { + gst_av1_dec_image_to_buffer (av1dec, img, frame->output_buffer); + ret = gst_video_decoder_finish_frame (dec, frame); + } else { + gst_video_decoder_drop_frame (dec, frame); + } + + aom_img_free (img); + while ((img = aom_codec_get_frame (&av1dec->decoder, &iter))) { + GST_WARNING_OBJECT (dec, "Multiple decoded frames... dropping"); + aom_img_free (img); + } + } else { + GST_VIDEO_CODEC_FRAME_SET_DECODE_ONLY (frame); + gst_video_decoder_finish_frame (dec, frame); + } + + + return ret; +} diff --git a/ext/aom/gstav1dec.h b/ext/aom/gstav1dec.h new file mode 100644 index 0000000000..b793fdedbd --- /dev/null +++ b/ext/aom/gstav1dec.h @@ -0,0 +1,70 @@ +/* GStreamer + * Copyright (C) <2017> Sean DuBois + * + * 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_AV1_DEC_H__ +#define __GST_AV1_DEC_H__ + + +#include +#include + +#include +#include + +G_BEGIN_DECLS +#define GST_TYPE_AV1_DEC \ + (gst_av1_dec_get_type()) +#define GST_AV1_DEC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AV1_DEC,GstAV1Dec)) +#define GST_AV1_DEC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AV1_DEC,GstAV1DecClass)) +#define GST_IS_AV1_DEC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AV1_DEC)) +#define GST_IS_AV1_DEC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AV1_DEC)) +#define GST_AV1_DEC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_AV1_DEC, GstAV1DecClass)) + +typedef struct _GstAV1Dec GstAV1Dec; +typedef struct _GstAV1DecClass GstAV1DecClass; + +struct _GstAV1Dec +{ + GstVideoDecoder base_video_decoder; + + gboolean decoder_inited; + + aom_codec_ctx_t decoder; + + GstVideoCodecState *input_state; + GstVideoCodecState *output_state; +}; + +struct _GstAV1DecClass +{ + GstVideoDecoderClass parent_class; + /*supported aom algo*/ + aom_codec_iface_t* codec_algo; +}; + +GType gst_av1_dec_get_type (void); + +G_END_DECLS +#endif /* __GST_AV1_DEC_H__ */ diff --git a/ext/aom/gstav1enc.c b/ext/aom/gstav1enc.c new file mode 100644 index 0000000000..547023048e --- /dev/null +++ b/ext/aom/gstav1enc.c @@ -0,0 +1,350 @@ +/* GStreamer + * Copyright (C) <2017> Sean DuBois + * + * 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. + */ +/** + * SECTION:element-av1enc + * + * AV1 Encoder. + * + * + * Example launch line + * |[ + * gst-launch-1.0 videotestsrc num-buffers=50 ! av1enc ! webmmux ! filesink location=av1.webm + * ]| + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstav1enc.h" +#include +#include +#include + +GST_DEBUG_CATEGORY_STATIC (av1_enc_debug); +#define GST_CAT_DEFAULT av1_enc_debug + +enum +{ + LAST_SIGNAL +}; + +enum +{ + PROP_0 +}; + +static void gst_av1_enc_finalize (GObject * object); + +static void gst_av1_enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_av1_enc_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static gboolean gst_av1_enc_start (GstVideoEncoder * benc); +static gboolean gst_av1_enc_stop (GstVideoEncoder * benc); +static gboolean gst_av1_enc_set_format (GstVideoEncoder * encoder, + GstVideoCodecState * state); +static GstFlowReturn gst_av1_enc_handle_frame (GstVideoEncoder * encoder, + GstVideoCodecFrame * frame); +static gboolean gst_av1_enc_propose_allocation (GstVideoEncoder * encoder, + GstQuery * query); + +#define gst_av1_enc_parent_class parent_class +G_DEFINE_TYPE (GstAV1Enc, gst_av1_enc, GST_TYPE_VIDEO_ENCODER); + +/* *INDENT-OFF* */ +static GstStaticPadTemplate gst_av1_enc_sink_pad_template = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-raw, " + "format = (string) \"I420\", " + "framerate = (fraction) [0, MAX], " + "width = (int) [ 4, MAX ], " + "height = (int) [ 4, MAX ]") + ); +/* *INDENT-ON* */ + +static GstStaticPadTemplate gst_av1_enc_src_pad_template = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-av1") + ); + +static void +gst_av1_enc_class_init (GstAV1EncClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *element_class; + GstVideoEncoderClass *venc_class; + + gobject_class = (GObjectClass *) klass; + element_class = (GstElementClass *) klass; + venc_class = (GstVideoEncoderClass *) klass; + + parent_class = g_type_class_peek_parent (klass); + + gobject_class->finalize = gst_av1_enc_finalize; + gobject_class->set_property = gst_av1_enc_set_property; + gobject_class->get_property = gst_av1_enc_get_property; + + gst_element_class_add_static_pad_template (element_class, + &gst_av1_enc_sink_pad_template); + gst_element_class_add_static_pad_template (element_class, + &gst_av1_enc_src_pad_template); + gst_element_class_set_static_metadata (element_class, "AV1 Encoder", + "Codec/Encoder/Video", "Encode AV1 video streams", + "Sean DuBois "); + + venc_class->start = gst_av1_enc_start; + venc_class->stop = gst_av1_enc_stop; + venc_class->set_format = gst_av1_enc_set_format; + venc_class->handle_frame = gst_av1_enc_handle_frame; + venc_class->propose_allocation = gst_av1_enc_propose_allocation; + + GST_DEBUG_CATEGORY_INIT (av1_enc_debug, "av1enc", 0, "AV1 encoding element"); +} + +static void +gst_av1_codec_error (aom_codec_ctx_t * ctx, const char *s) +{ + const char *detail = aom_codec_error_detail (ctx); + + g_print ("%s: %s\n", s, aom_codec_error (ctx)); + if (detail) { + g_print (" %s\n", detail); + } +} + +static void +gst_av1_enc_init (GstAV1Enc * av1enc) +{ + GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_ENCODER_SINK_PAD (av1enc)); +} + +static void +gst_av1_enc_finalize (GObject * object) +{ + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gst_av1_enc_set_latency (GstAV1Enc * encoder) +{ + GstAV1Enc *av1enc = GST_AV1_ENC (encoder); + GstClockTime latency = + gst_util_uint64_scale (av1enc->aom_cfg.g_lag_in_frames, 1 * GST_SECOND, + 30); + gst_video_encoder_set_latency (GST_VIDEO_ENCODER (encoder), latency, latency); + + GST_WARNING_OBJECT (encoder, "Latency unimplemented"); +} + +static gboolean +gst_av1_enc_init_aom (GstAV1Enc * av1enc) +{ + av1enc->codec_interface = &aom_codec_av1_cx_algo; + + if (aom_codec_enc_config_default (av1enc->codec_interface, &av1enc->aom_cfg, + 0)) { + gst_av1_codec_error (&av1enc->codec, "Failed to get default codec config."); + return FALSE; + } + + av1enc->aom_cfg.g_w = av1enc->input_state->info.width; + av1enc->aom_cfg.g_h = av1enc->input_state->info.height; + av1enc->aom_cfg.g_timebase.num = av1enc->input_state->info.fps_d; + av1enc->aom_cfg.g_timebase.den = av1enc->input_state->info.fps_n; + av1enc->aom_cfg.rc_target_bitrate = 3000; + av1enc->aom_cfg.g_error_resilient = 0; + + if (aom_codec_enc_init (&av1enc->codec, av1enc->codec_interface, + &av1enc->aom_cfg, 0)) { + gst_av1_codec_error (&av1enc->codec, "Failed to initialize encoder"); + return FALSE; + } + + return TRUE; +} + + +static gboolean +gst_av1_enc_set_format (GstVideoEncoder * encoder, GstVideoCodecState * state) +{ + GstVideoCodecState *output_state; + GstAV1Enc *av1enc = GST_AV1_ENC (encoder); + + av1enc->keyframe_dist = 30; + + output_state = + gst_video_encoder_set_output_state (encoder, + gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD (encoder)), + state); + gst_video_codec_state_unref (output_state); + + av1enc->input_state = gst_video_codec_state_ref (state); + + gst_av1_enc_set_latency (av1enc); + return gst_av1_enc_init_aom (av1enc); +} + +static GstFlowReturn +gst_av1_enc_process (GstAV1Enc * encoder) +{ + aom_codec_iter_t iter = NULL; + const aom_codec_cx_pkt_t *pkt; + GstVideoCodecFrame *frame; + GstVideoEncoder *video_encoder; + + video_encoder = GST_VIDEO_ENCODER (encoder); + + while ((pkt = aom_codec_get_cx_data (&encoder->codec, &iter)) != NULL) { + if (pkt->kind == AOM_CODEC_STATS_PKT) { + GST_WARNING_OBJECT (encoder, "Unhandled stats packet"); + } else if (pkt->kind == AOM_CODEC_FPMB_STATS_PKT) { + GST_WARNING_OBJECT (encoder, "Unhandled FPMB pkt"); + } else if (pkt->kind == AOM_CODEC_PSNR_PKT) { + GST_WARNING_OBJECT (encoder, "Unhandled PSNR packet"); + } else if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) { + frame = gst_video_encoder_get_oldest_frame (video_encoder); + g_assert (frame != NULL); + if ((pkt->data.frame.flags & AOM_FRAME_IS_KEY) != 0) { + GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame); + } else { + GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame); + } + + frame->output_buffer = + gst_buffer_new_wrapped (g_memdup (pkt->data.frame.buf, + pkt->data.frame.sz), pkt->data.frame.sz); + gst_video_encoder_finish_frame (video_encoder, frame); + } + } + + return GST_FLOW_OK; +} + +static void +gst_av1_enc_fill_image (GstAV1Enc * enc, GstVideoFrame * frame, + aom_image_t * image) +{ + image->planes[AOM_PLANE_Y] = GST_VIDEO_FRAME_COMP_DATA (frame, 0); + image->planes[AOM_PLANE_U] = GST_VIDEO_FRAME_COMP_DATA (frame, 1); + image->planes[AOM_PLANE_V] = GST_VIDEO_FRAME_COMP_DATA (frame, 2); + + image->stride[AOM_PLANE_Y] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0); + image->stride[AOM_PLANE_U] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 1); + image->stride[AOM_PLANE_V] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 2); +} + +static GstFlowReturn +gst_av1_enc_handle_frame (GstVideoEncoder * encoder, GstVideoCodecFrame * frame) +{ + GstAV1Enc *av1enc = GST_AV1_ENC (encoder); + aom_image_t raw; + int flags = 0; + GstFlowReturn ret; + GstVideoFrame vframe; + + if (!aom_img_alloc (&raw, AOM_IMG_FMT_I420, av1enc->aom_cfg.g_w, + av1enc->aom_cfg.g_h, 1)) { + GST_ERROR_OBJECT (encoder, "Failed to initialize encoder"); + return FALSE; + } + + gst_video_frame_map (&vframe, &av1enc->input_state->info, + frame->input_buffer, GST_MAP_READ); + gst_av1_enc_fill_image (av1enc, &vframe, &raw); + gst_video_frame_unmap (&vframe); + + if (av1enc->keyframe_dist >= 30) { + av1enc->keyframe_dist = 0; + flags |= AOM_EFLAG_FORCE_KF; + } + av1enc->keyframe_dist++; + + if (aom_codec_encode (&av1enc->codec, &raw, frame->pts, 1, flags, + AOM_DL_GOOD_QUALITY) != AOM_CODEC_OK) { + gst_av1_codec_error (&av1enc->codec, "Failed to encode frame"); + } + + ret = gst_av1_enc_process (av1enc); + aom_img_free (&raw); + return ret; +} + +static gboolean +gst_av1_enc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query) +{ + gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL); + + return GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder, + query); +} + +static void +gst_av1_enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstAV1Enc *av1enc = GST_AV1_ENC (object); + + GST_OBJECT_LOCK (av1enc); + + switch (prop_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } + + GST_OBJECT_UNLOCK (av1enc); +} + +static void +gst_av1_enc_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstAV1Enc *av1enc = GST_AV1_ENC (object); + + GST_OBJECT_LOCK (av1enc); + + switch (prop_id) { + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } + + GST_OBJECT_UNLOCK (av1enc); +} + +static gboolean +gst_av1_enc_start (GstVideoEncoder * encoder) +{ + return TRUE; +} + +static gboolean +gst_av1_enc_stop (GstVideoEncoder * benc) +{ + g_print ("AV1Enc Stop \n"); + return TRUE; +} diff --git a/ext/aom/gstav1enc.h b/ext/aom/gstav1enc.h new file mode 100644 index 0000000000..2493d8c444 --- /dev/null +++ b/ext/aom/gstav1enc.h @@ -0,0 +1,69 @@ +/* GStreamer + * Copyright (C) <2017> Sean DuBois + * + * 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_AV1_ENC_H__ +#define __GST_AV1_ENC_H__ + + +#include +#include +#include + +#include +#include +#include + +G_BEGIN_DECLS +#define GST_TYPE_AV1_ENC \ + (gst_av1_enc_get_type()) +#define GST_AV1_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AV1_ENC,GstAV1Enc)) +#define GST_AV1_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AV1_ENC,GstAV1EncClass)) +#define GST_IS_AV1_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AV1_ENC)) +#define GST_IS_AV1_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AV1_ENC)) + +typedef struct _GstAV1Enc GstAV1Enc; +typedef struct _GstAV1EncClass GstAV1EncClass; + +struct _GstAV1Enc +{ + GstVideoEncoder encoder; + + guint keyframe_dist; + + GstVideoCodecState *input_state; + + aom_codec_iface_t *codec_interface; + aom_codec_enc_cfg_t aom_cfg; + aom_codec_ctx_t codec; +}; + +struct _GstAV1EncClass +{ + GstVideoEncoderClass parent_class; +}; + +GType gst_av1_enc_get_type (void); + +G_END_DECLS +#endif /* __GST_AV1_ENC_H__ */ diff --git a/ext/aom/meson.build b/ext/aom/meson.build new file mode 100644 index 0000000000..96b086ebd1 --- /dev/null +++ b/ext/aom/meson.build @@ -0,0 +1,11 @@ +aom_dep = dependency('aom', required: false) +if aom_dep.found() + gstaom = library('gstaom', + ['gstaom.c', 'gstav1enc.c', 'gstav1dec.c'], + c_args : gst_plugins_bad_args, + include_directories : [configinc], + dependencies : [gstpbutils_dep, gstvideo_dep, aom_dep], + install : true, + install_dir : plugins_install_dir, + ) +endif diff --git a/ext/meson.build b/ext/meson.build index fbe3513d22..dce4e74802 100644 --- a/ext/meson.build +++ b/ext/meson.build @@ -1,4 +1,5 @@ subdir('assrender') +subdir('aom') #subdir('bs2b') subdir('bz2') subdir('chromaprint')