mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-26 19:51:11 +00:00
Code Issues 1 Projects Releases Wiki Activity

Add aom plugin with av1enc and av1dec element

Browse source 
https://bugzilla.gnome.org/show_bug.cgi?id=784160
This commit is contained in:
Sean DuBois 2017-06-27 22:50:41 +00:00 committed by Edward Hervey
parent f2dac588dc
commit 1c583fd27b
11 changed files with 954 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
configure.ac
View file

@ -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

8
ext/Makefile.am
View file

@ -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 \

15
ext/aom/Makefile.am Normal file
View file

@ -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

50
ext/aom/gstaom.c Normal file
View file

@ -0,0 +1,50 @@
/* GStreamer
* Copyright (C) <2017> Sean DuBois <sean@siobud.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 <gst/gst.h>
#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)

24
ext/aom/gstaom.h Normal file
View file

@ -0,0 +1,24 @@
/* GStreamer
* Copyright (C) <2017> Sean DuBois <sean@siobud.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_AOM_H__
#define __GST_AOM_H__
#endif /* __GST_AOM_H__ */

348
ext/aom/gstav1dec.c Normal file
View file

@ -0,0 +1,348 @@
/* GStreamer
* Copyright (C) <2017> Sean DuBois <sean@siobud.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.
*/
/**
* SECTION:element-av1dec
*
* AV1 Decoder.
*
* <refsect2>
* <title>Example launch line</title>
* |[
* gst-launch-1.0 -v filesrc location=videotestsrc.webm ! matroskademux ! av1dec ! videoconvert ! videoscale ! autovideosink
* ]|
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#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 <sean@siobud.com>");
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;
}

70
ext/aom/gstav1dec.h Normal file
View file

@ -0,0 +1,70 @@
/* GStreamer
* Copyright (C) <2017> Sean DuBois <sean@siobud.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_AV1_DEC_H__
#define __GST_AV1_DEC_H__
#include <gst/gst.h>
#include <gst/video/gstvideodecoder.h>
#include <aom/aomdx.h>
#include <aom/aom_decoder.h>
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__ */

350
ext/aom/gstav1enc.c Normal file
View file

@ -0,0 +1,350 @@
/* GStreamer
* Copyright (C) <2017> Sean DuBois <sean@siobud.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.
*/
/**
* SECTION:element-av1enc
*
* AV1 Encoder.
*
* <refsect2>
* <title>Example launch line</title>
* |[
* gst-launch-1.0 videotestsrc num-buffers=50 ! av1enc ! webmmux ! filesink location=av1.webm
* ]|
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstav1enc.h"
#include <gst/video/video.h>
#include <gst/video/gstvideometa.h>
#include <gst/base/base.h>
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 <sean@siobud.com>");
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;
}

69
ext/aom/gstav1enc.h Normal file
View file

@ -0,0 +1,69 @@
/* GStreamer
* Copyright (C) <2017> Sean DuBois <sean@siobud.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_AV1_ENC_H__
#define __GST_AV1_ENC_H__
#include <gst/gst.h>
#include <gst/video/video.h>
#include <gst/video/gstvideoencoder.h>
#include <aom/aom_codec.h>
#include <aom/aom_encoder.h>
#include <aom/aomcx.h>
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__ */

11
ext/aom/meson.build Normal file
View file

@ -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

1
ext/meson.build
View file

@ -1,4 +1,5 @@
subdir('assrender')
subdir('aom')
#subdir('bs2b')
subdir('bz2')
subdir('chromaprint')