From f67af2936fe84765b87ce2f8e0ce629908788b92 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 21 Jun 2013 13:07:30 +0200 Subject: [PATCH] vpx: Add initial, experimental VP9 support --- configure.ac | 12 + ext/vpx/Makefile.am | 4 + ext/vpx/gstvp9dec.c | 588 ++++++++++++++++ ext/vpx/gstvp9dec.h | 84 +++ ext/vpx/gstvp9enc.c | 1911 +++++++++++++++++++++++++++++++++++++++++++++++++++ ext/vpx/gstvp9enc.h | 113 +++ ext/vpx/plugin.c | 12 + 7 files changed, 2724 insertions(+) create mode 100644 ext/vpx/gstvp9dec.c create mode 100644 ext/vpx/gstvp9dec.h create mode 100644 ext/vpx/gstvp9enc.c create mode 100644 ext/vpx/gstvp9enc.h diff --git a/configure.ac b/configure.ac index f7ba2fb..b89bb8a 100644 --- a/configure.ac +++ b/configure.ac @@ -945,6 +945,8 @@ dnl *** vpx *** translit(dnm, m, l) AM_CONDITIONAL(USE_VPX, vpx) AG_GST_CHECK_FEATURE(VPX, [VPX decoder], vpx, [ PKG_CHECK_MODULES(VPX, vpx >= 1.1.0, [HAVE_VPX="yes"], [HAVE_VPX="no"]) + HAVE_VP8=no + HAVE_VP9=no if test $HAVE_VPX = "yes"; then OLD_LIBS="$LIBS" @@ -959,6 +961,16 @@ AG_GST_CHECK_FEATURE(VPX, [VPX decoder], vpx, [ HAVE_VP8=yes AC_DEFINE(HAVE_VP8_DECODER, 1, [Defined if the VP8 decoder is available]) ]) + if test "x$BUILD_EXPERIMENTAL" = "xyes"; then + AC_CHECK_LIB(vpx, vpx_codec_vp9_cx_algo, [ + HAVE_VP9=yes + AC_DEFINE(HAVE_VP9_ENCODER, 1, [Defined if the VP9 encoder is available]) + ]) + AC_CHECK_LIB(vpx, vpx_codec_vp9_dx_algo, [ + HAVE_VP9=yes + AC_DEFINE(HAVE_VP9_DECODER, 1, [Defined if the VP9 decoder is available]) + ]) + fi LIBS="$OLD_LIBS" CFLAGS="$OLD_CFLAGS" fi diff --git a/ext/vpx/Makefile.am b/ext/vpx/Makefile.am index 10b0b35..1763638 100644 --- a/ext/vpx/Makefile.am +++ b/ext/vpx/Makefile.am @@ -5,6 +5,8 @@ libgstvpx_la_SOURCES = \ gstvp8dec.c \ gstvp8enc.c \ gstvp8utils.c \ + gstvp9dec.c \ + gstvp9enc.c \ plugin.c libgstvpx_la_CFLAGS = \ @@ -22,6 +24,8 @@ libgstvpx_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS) noinst_HEADERS = \ gstvp8dec.h \ gstvp8enc.h \ + gstvp9dec.h \ + gstvp9enc.h \ gstvp8utils.h presetdir = $(datadir)/gstreamer-$(GST_API_VERSION)/presets diff --git a/ext/vpx/gstvp9dec.c b/ext/vpx/gstvp9dec.c new file mode 100644 index 0000000..457096b --- /dev/null +++ b/ext/vpx/gstvp9dec.c @@ -0,0 +1,588 @@ +/* VP9 + * Copyright (C) 2006 David Schleef + * Copyright (C) 2008,2009,2010 Entropy Wave Inc + * Copyright (C) 2010-2013 Sebastian Dröge + * + * 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-vp9dec + * @see_also: vp9enc, matroskademux + * + * This element decodes VP9 streams into raw video. + * VP9 is a royalty-free + * video codec maintained by Google + * . It's the successor of On2 VP3, which was the base of the + * Theora video codec. + * + * + * Example pipeline + * |[ + * gst-launch -v filesrc location=videotestsrc.webm ! matroskademux ! vp9dec ! xvimagesink + * ]| This example pipeline will decode a WebM stream and decodes the VP9 video. + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef HAVE_VP9_DECODER + +#include + +#include "gstvp8utils.h" +#include "gstvp9dec.h" + +#include +#include + +GST_DEBUG_CATEGORY_STATIC (gst_vp9dec_debug); +#define GST_CAT_DEFAULT gst_vp9dec_debug + +#define DEFAULT_POST_PROCESSING FALSE +#define DEFAULT_POST_PROCESSING_FLAGS (VP8_DEBLOCK | VP8_DEMACROBLOCK | VP8_MFQE) +#define DEFAULT_DEBLOCKING_LEVEL 4 +#define DEFAULT_NOISE_LEVEL 0 +#define DEFAULT_THREADS 1 + +enum +{ + PROP_0, + PROP_POST_PROCESSING, + PROP_POST_PROCESSING_FLAGS, + PROP_DEBLOCKING_LEVEL, + PROP_NOISE_LEVEL, + PROP_THREADS +}; + +#define C_FLAGS(v) ((guint) v) +#define GST_VP9_DEC_TYPE_POST_PROCESSING_FLAGS (gst_vp9_dec_post_processing_flags_get_type()) +static GType +gst_vp9_dec_post_processing_flags_get_type (void) +{ + static const GFlagsValue values[] = { + {C_FLAGS (VP8_DEBLOCK), "Deblock", "deblock"}, + {C_FLAGS (VP8_DEMACROBLOCK), "Demacroblock", "demacroblock"}, + {C_FLAGS (VP8_ADDNOISE), "Add noise", "addnoise"}, + {C_FLAGS (VP8_MFQE), "Multi-frame quality enhancement", "mfqe"}, + {0, NULL, NULL} + }; + static volatile GType id = 0; + + if (g_once_init_enter ((gsize *) & id)) { + GType _id; + + _id = g_flags_register_static ("GstVP9DecPostProcessingFlags", values); + + g_once_init_leave ((gsize *) & id, _id); + } + + return id; +} + +#undef C_FLAGS + +static void gst_vp9_dec_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_vp9_dec_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static gboolean gst_vp9_dec_start (GstVideoDecoder * decoder); +static gboolean gst_vp9_dec_stop (GstVideoDecoder * decoder); +static gboolean gst_vp9_dec_set_format (GstVideoDecoder * decoder, + GstVideoCodecState * state); +static gboolean gst_vp9_dec_reset (GstVideoDecoder * decoder, gboolean hard); +static GstFlowReturn gst_vp9_dec_handle_frame (GstVideoDecoder * decoder, + GstVideoCodecFrame * frame); +static gboolean gst_vp9_dec_decide_allocation (GstVideoDecoder * decoder, + GstQuery * query); + +static GstStaticPadTemplate gst_vp9_dec_sink_template = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-vp9") + ); + +static GstStaticPadTemplate gst_vp9_dec_src_template = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("I420")) + ); + +#define parent_class gst_vp9_dec_parent_class +G_DEFINE_TYPE (GstVP9Dec, gst_vp9_dec, GST_TYPE_VIDEO_DECODER); + +static void +gst_vp9_dec_class_init (GstVP9DecClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *element_class; + GstVideoDecoderClass *base_video_decoder_class; + + gobject_class = G_OBJECT_CLASS (klass); + element_class = GST_ELEMENT_CLASS (klass); + base_video_decoder_class = GST_VIDEO_DECODER_CLASS (klass); + + gobject_class->set_property = gst_vp9_dec_set_property; + gobject_class->get_property = gst_vp9_dec_get_property; + + g_object_class_install_property (gobject_class, PROP_POST_PROCESSING, + g_param_spec_boolean ("post-processing", "Post Processing", + "Enable post processing", DEFAULT_POST_PROCESSING, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_POST_PROCESSING_FLAGS, + g_param_spec_flags ("post-processing-flags", "Post Processing Flags", + "Flags to control post processing", + GST_VP9_DEC_TYPE_POST_PROCESSING_FLAGS, DEFAULT_POST_PROCESSING_FLAGS, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_DEBLOCKING_LEVEL, + g_param_spec_uint ("deblocking-level", "Deblocking Level", + "Deblocking level", + 0, 16, DEFAULT_DEBLOCKING_LEVEL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_NOISE_LEVEL, + g_param_spec_uint ("noise-level", "Noise Level", + "Noise level", + 0, 16, DEFAULT_NOISE_LEVEL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_THREADS, + g_param_spec_uint ("threads", "Max Threads", + "Maximum number of decoding threads", + 1, 16, DEFAULT_THREADS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_vp9_dec_src_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_vp9_dec_sink_template)); + + gst_element_class_set_static_metadata (element_class, + "On2 VP9 Decoder", + "Codec/Decoder/Video", + "Decode VP9 video streams", "David Schleef , " + "Sebastian Dröge "); + + base_video_decoder_class->start = GST_DEBUG_FUNCPTR (gst_vp9_dec_start); + base_video_decoder_class->stop = GST_DEBUG_FUNCPTR (gst_vp9_dec_stop); + base_video_decoder_class->reset = GST_DEBUG_FUNCPTR (gst_vp9_dec_reset); + base_video_decoder_class->set_format = + GST_DEBUG_FUNCPTR (gst_vp9_dec_set_format); + base_video_decoder_class->handle_frame = + GST_DEBUG_FUNCPTR (gst_vp9_dec_handle_frame); + base_video_decoder_class->decide_allocation = gst_vp9_dec_decide_allocation; + + GST_DEBUG_CATEGORY_INIT (gst_vp9dec_debug, "vp9dec", 0, "VP9 Decoder"); +} + +static void +gst_vp9_dec_init (GstVP9Dec * gst_vp9_dec) +{ + GstVideoDecoder *decoder = (GstVideoDecoder *) gst_vp9_dec; + + GST_DEBUG_OBJECT (gst_vp9_dec, "gst_vp9_dec_init"); + gst_video_decoder_set_packetized (decoder, TRUE); + gst_vp9_dec->post_processing = DEFAULT_POST_PROCESSING; + gst_vp9_dec->post_processing_flags = DEFAULT_POST_PROCESSING_FLAGS; + gst_vp9_dec->deblocking_level = DEFAULT_DEBLOCKING_LEVEL; + gst_vp9_dec->noise_level = DEFAULT_NOISE_LEVEL; +} + +static void +gst_vp9_dec_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstVP9Dec *dec; + + g_return_if_fail (GST_IS_VP9_DEC (object)); + dec = GST_VP9_DEC (object); + + GST_DEBUG_OBJECT (object, "gst_vp9_dec_set_property"); + switch (prop_id) { + case PROP_POST_PROCESSING: + dec->post_processing = g_value_get_boolean (value); + break; + case PROP_POST_PROCESSING_FLAGS: + dec->post_processing_flags = g_value_get_flags (value); + break; + case PROP_DEBLOCKING_LEVEL: + dec->deblocking_level = g_value_get_uint (value); + break; + case PROP_NOISE_LEVEL: + dec->noise_level = g_value_get_uint (value); + break; + case PROP_THREADS: + dec->threads = g_value_get_uint (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_vp9_dec_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstVP9Dec *dec; + + g_return_if_fail (GST_IS_VP9_DEC (object)); + dec = GST_VP9_DEC (object); + + switch (prop_id) { + case PROP_POST_PROCESSING: + g_value_set_boolean (value, dec->post_processing); + break; + case PROP_POST_PROCESSING_FLAGS: + g_value_set_flags (value, dec->post_processing_flags); + break; + case PROP_DEBLOCKING_LEVEL: + g_value_set_uint (value, dec->deblocking_level); + break; + case PROP_NOISE_LEVEL: + g_value_set_uint (value, dec->noise_level); + break; + case PROP_THREADS: + g_value_set_uint (value, dec->threads); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static gboolean +gst_vp9_dec_start (GstVideoDecoder * decoder) +{ + GstVP9Dec *gst_vp9_dec = GST_VP9_DEC (decoder); + + GST_DEBUG_OBJECT (gst_vp9_dec, "start"); + gst_vp9_dec->decoder_inited = FALSE; + + return TRUE; +} + +static gboolean +gst_vp9_dec_stop (GstVideoDecoder * base_video_decoder) +{ + GstVP9Dec *gst_vp9_dec = GST_VP9_DEC (base_video_decoder); + + GST_DEBUG_OBJECT (gst_vp9_dec, "stop"); + + if (gst_vp9_dec->output_state) { + gst_video_codec_state_unref (gst_vp9_dec->output_state); + gst_vp9_dec->output_state = NULL; + } + + if (gst_vp9_dec->input_state) { + gst_video_codec_state_unref (gst_vp9_dec->input_state); + gst_vp9_dec->input_state = NULL; + } + + if (gst_vp9_dec->decoder_inited) + vpx_codec_destroy (&gst_vp9_dec->decoder); + gst_vp9_dec->decoder_inited = FALSE; + + return TRUE; +} + +static gboolean +gst_vp9_dec_set_format (GstVideoDecoder * decoder, GstVideoCodecState * state) +{ + GstVP9Dec *gst_vp9_dec = GST_VP9_DEC (decoder); + + GST_DEBUG_OBJECT (gst_vp9_dec, "set_format"); + + if (gst_vp9_dec->decoder_inited) + vpx_codec_destroy (&gst_vp9_dec->decoder); + gst_vp9_dec->decoder_inited = FALSE; + + if (gst_vp9_dec->input_state) + gst_video_codec_state_unref (gst_vp9_dec->input_state); + gst_vp9_dec->input_state = gst_video_codec_state_ref (state); + + return TRUE; +} + +static gboolean +gst_vp9_dec_reset (GstVideoDecoder * base_video_decoder, gboolean hard) +{ + GstVP9Dec *decoder; + + GST_DEBUG_OBJECT (base_video_decoder, "reset"); + + decoder = GST_VP9_DEC (base_video_decoder); + + if (decoder->output_state) { + gst_video_codec_state_unref (decoder->output_state); + decoder->output_state = NULL; + } + + if (decoder->decoder_inited) + vpx_codec_destroy (&decoder->decoder); + decoder->decoder_inited = FALSE; + + return TRUE; +} + +static void +gst_vp9_dec_send_tags (GstVP9Dec * dec) +{ + GstTagList *list; + + list = gst_tag_list_new_empty (); + gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, + GST_TAG_VIDEO_CODEC, "VP9 video", NULL); + + gst_pad_push_event (GST_VIDEO_DECODER_SRC_PAD (dec), + gst_event_new_tag (list)); +} + +static void +gst_vp9_dec_image_to_buffer (GstVP9Dec * dec, const vpx_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"); + } + + 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); + height = GST_VIDEO_FRAME_COMP_HEIGHT (&frame, comp); + deststride = GST_VIDEO_FRAME_COMP_STRIDE (&frame, comp); + srcstride = img->stride[comp]; + + /* FIXME (Edward) : Do a plane memcpy is srcstride == deststride instead + * of copying line by line */ + for (line = 0; line < height; line++) { + memcpy (dest, src, width); + dest += deststride; + src += srcstride; + } + } + + gst_video_frame_unmap (&frame); +} + +static GstFlowReturn +open_codec (GstVP9Dec * dec, GstVideoCodecFrame * frame) +{ + int flags = 0; + vpx_codec_stream_info_t stream_info; + vpx_codec_caps_t caps; + vpx_codec_dec_cfg_t cfg; + GstVideoCodecState *state = dec->input_state; + vpx_codec_err_t status; + GstMapInfo minfo; + + memset (&stream_info, 0, sizeof (stream_info)); + memset (&cfg, 0, sizeof (cfg)); + stream_info.sz = sizeof (stream_info); + + if (!gst_buffer_map (frame->input_buffer, &minfo, GST_MAP_READ)) { + GST_ERROR_OBJECT (dec, "Failed to map input buffer"); + return GST_FLOW_ERROR; + } + + status = vpx_codec_peek_stream_info (&vpx_codec_vp9_dx_algo, + minfo.data, minfo.size, &stream_info); + + gst_buffer_unmap (frame->input_buffer, &minfo); + + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (dec, "VPX preprocessing error: %s", + gst_vpx_error_name (status)); + gst_video_decoder_finish_frame (GST_VIDEO_DECODER (dec), frame); + return GST_FLOW_CUSTOM_SUCCESS_1; + } + if (!stream_info.is_kf) { + GST_WARNING_OBJECT (dec, "No keyframe, skipping"); + gst_video_decoder_finish_frame (GST_VIDEO_DECODER (dec), frame); + return GST_FLOW_CUSTOM_SUCCESS_1; + } + + /* FIXME: peek_stream_info() does not return valid values, take input caps */ + stream_info.w = dec->input_state->info.width; + stream_info.h = dec->input_state->info.height; + + g_assert (dec->output_state == NULL); + dec->output_state = + gst_video_decoder_set_output_state (GST_VIDEO_DECODER (dec), + GST_VIDEO_FORMAT_I420, stream_info.w, stream_info.h, state); + gst_video_decoder_negotiate (GST_VIDEO_DECODER (dec)); + gst_vp9_dec_send_tags (dec); + + cfg.w = stream_info.w; + cfg.h = stream_info.h; + cfg.threads = dec->threads; + + caps = vpx_codec_get_caps (&vpx_codec_vp9_dx_algo); + + if (dec->post_processing) { + if (!(caps & VPX_CODEC_CAP_POSTPROC)) { + GST_WARNING_OBJECT (dec, "Decoder does not support post processing"); + } else { + flags |= VPX_CODEC_USE_POSTPROC; + } + } + + status = + vpx_codec_dec_init (&dec->decoder, &vpx_codec_vp9_dx_algo, &cfg, flags); + if (status != VPX_CODEC_OK) { + GST_ELEMENT_ERROR (dec, LIBRARY, INIT, + ("Failed to initialize VP9 decoder"), ("%s", + gst_vpx_error_name (status))); + return GST_FLOW_ERROR; + } + + if ((caps & VPX_CODEC_CAP_POSTPROC) && dec->post_processing) { + vp8_postproc_cfg_t pp_cfg = { 0, }; + + pp_cfg.post_proc_flag = dec->post_processing_flags; + pp_cfg.deblocking_level = dec->deblocking_level; + pp_cfg.noise_level = dec->noise_level; + + status = vpx_codec_control (&dec->decoder, VP8_SET_POSTPROC, &pp_cfg); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (dec, "Couldn't set postprocessing settings: %s", + gst_vpx_error_name (status)); + } + } + + dec->decoder_inited = TRUE; + + return GST_FLOW_OK; +} + +static GstFlowReturn +gst_vp9_dec_handle_frame (GstVideoDecoder * decoder, GstVideoCodecFrame * frame) +{ + GstVP9Dec *dec; + GstFlowReturn ret = GST_FLOW_OK; + vpx_codec_err_t status; + vpx_codec_iter_t iter = NULL; + vpx_image_t *img; + long decoder_deadline = 0; + GstClockTimeDiff deadline; + GstMapInfo minfo; + + GST_DEBUG_OBJECT (decoder, "handle_frame"); + + dec = GST_VP9_DEC (decoder); + + if (!dec->decoder_inited) { + ret = open_codec (dec, frame); + if (ret == GST_FLOW_CUSTOM_SUCCESS_1) + return GST_FLOW_OK; + else if (ret != GST_FLOW_OK) + return ret; + } + + deadline = gst_video_decoder_get_max_decode_time (decoder, frame); + if (deadline < 0) { + decoder_deadline = 1; + } else if (deadline == G_MAXINT64) { + decoder_deadline = 0; + } else { + decoder_deadline = MAX (1, deadline / GST_MSECOND); + } + + if (!gst_buffer_map (frame->input_buffer, &minfo, GST_MAP_READ)) { + GST_ERROR_OBJECT (dec, "Failed to map input buffer"); + return GST_FLOW_ERROR; + } + + status = vpx_codec_decode (&dec->decoder, + minfo.data, minfo.size, NULL, decoder_deadline); + + gst_buffer_unmap (frame->input_buffer, &minfo); + + if (status) { + GST_VIDEO_DECODER_ERROR (decoder, 1, LIBRARY, ENCODE, + ("Failed to decode frame"), ("%s", gst_vpx_error_name (status)), ret); + return ret; + } + + img = vpx_codec_get_frame (&dec->decoder, &iter); + if (img) { + if (deadline < 0) { + GST_LOG_OBJECT (dec, "Skipping late frame (%f s past deadline)", + (double) -deadline / GST_SECOND); + gst_video_decoder_drop_frame (decoder, frame); + } else { + ret = gst_video_decoder_allocate_output_frame (decoder, frame); + + if (ret == GST_FLOW_OK) { + gst_vp9_dec_image_to_buffer (dec, img, frame->output_buffer); + ret = gst_video_decoder_finish_frame (decoder, frame); + } else { + gst_video_decoder_finish_frame (decoder, frame); + } + } + + vpx_img_free (img); + + while ((img = vpx_codec_get_frame (&dec->decoder, &iter))) { + GST_WARNING_OBJECT (decoder, "Multiple decoded frames... dropping"); + vpx_img_free (img); + } + } else { + /* Invisible frame */ + GST_VIDEO_CODEC_FRAME_SET_DECODE_ONLY (frame); + gst_video_decoder_finish_frame (decoder, frame); + } + + return ret; +} + +static gboolean +gst_vp9_dec_decide_allocation (GstVideoDecoder * bdec, GstQuery * query) +{ + GstBufferPool *pool; + GstStructure *config; + + if (!GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation (bdec, query)) + return FALSE; + + g_assert (gst_query_get_n_allocation_pools (query) > 0); + gst_query_parse_nth_allocation_pool (query, 0, &pool, NULL, NULL, NULL); + g_assert (pool != NULL); + + config = gst_buffer_pool_get_config (pool); + if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL)) { + gst_buffer_pool_config_add_option (config, + GST_BUFFER_POOL_OPTION_VIDEO_META); + } + gst_buffer_pool_set_config (pool, config); + gst_object_unref (pool); + + return TRUE; +} + +#endif /* HAVE_VP9_DECODER */ diff --git a/ext/vpx/gstvp9dec.h b/ext/vpx/gstvp9dec.h new file mode 100644 index 0000000..ae27f7e --- /dev/null +++ b/ext/vpx/gstvp9dec.h @@ -0,0 +1,84 @@ +/* VP9 + * Copyright (C) 2006 David Schleef + * Copyright (C) 2008,2009,2010 Entropy Wave Inc + * Copyright (C) 2010-2013 Sebastian Dröge + * + * 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_VP9_DEC_H__ +#define __GST_VP9_DEC_H__ + +#include +#include + +/* FIXME: Undef HAVE_CONFIG_H because vpx_codec.h uses it, + * which causes compilation failures */ +#ifdef HAVE_CONFIG_H +#undef HAVE_CONFIG_H +#endif + +#include +#include + +G_BEGIN_DECLS + +#define GST_TYPE_VP9_DEC \ + (gst_vp9_dec_get_type()) +#define GST_VP9_DEC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VP9_DEC,GstVP9Dec)) +#define GST_VP9_DEC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VP9_DEC,GstVP9DecClass)) +#define GST_IS_VP9_DEC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VP9_DEC)) +#define GST_IS_VP9_DEC_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VP9_DEC)) + +typedef struct _GstVP9Dec GstVP9Dec; +typedef struct _GstVP9DecClass GstVP9DecClass; + +struct _GstVP9Dec +{ + GstVideoDecoder base_video_decoder; + + /* < private > */ + vpx_codec_ctx_t decoder; + + /* state */ + gboolean decoder_inited; + + /* properties */ + gboolean post_processing; + enum vp8_postproc_level post_processing_flags; + gint deblocking_level; + gint noise_level; + gint threads; + + GstVideoCodecState *input_state; + GstVideoCodecState *output_state; +}; + +struct _GstVP9DecClass +{ + GstVideoDecoderClass base_video_decoder_class; +}; + +GType gst_vp9_dec_get_type (void); + +G_END_DECLS + +#endif /* __GST_VP9_DEC_H__ */ diff --git a/ext/vpx/gstvp9enc.c b/ext/vpx/gstvp9enc.c new file mode 100644 index 0000000..29beed5 --- /dev/null +++ b/ext/vpx/gstvp9enc.c @@ -0,0 +1,1911 @@ +/* VP9 + * Copyright (C) 2006 David Schleef + * Copyright (C) 2010 Entropy Wave Inc + * Copyright (C) 2010-2013 Sebastian Dröge + * + * 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-vp9enc + * @see_also: vp9dec, webmmux, oggmux + * + * This element encodes raw video into a VP9 stream. + * VP9 is a royalty-free + * video codec maintained by Google + * . It's the successor of On2 VP3, which was the base of the + * Theora video codec. + * + * To control the quality of the encoding, the #GstVP9Enc::target-bitrate, + * #GstVP9Enc::min-quantizer, #GstVP9Enc::max-quantizer or #GstVP9Enc::cq-level + * properties can be used. Which one is used depends on the mode selected by + * the #GstVP9Enc::end-usage property. + * See Encoder Parameters + * for explanation, examples for useful encoding parameters and more details + * on the encoding parameters. + * + * + * Example pipeline + * |[ + * gst-launch -v videotestsrc num-buffers=1000 ! vp9enc ! webmmux ! filesink location=videotestsrc.webm + * ]| This example pipeline will encode a test video source to VP9 muxed in an + * WebM container. + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef HAVE_VP9_ENCODER + +/* glib decided in 2.32 it would be a great idea to deprecated GValueArray without + * providing an alternative + * + * See https://bugzilla.gnome.org/show_bug.cgi?id=667228 + * */ +#define GLIB_DISABLE_DEPRECATION_WARNINGS + +#include +#include +#include + +#include "gstvp8utils.h" +#include "gstvp9enc.h" + +GST_DEBUG_CATEGORY_STATIC (gst_vp9enc_debug); +#define GST_CAT_DEFAULT gst_vp9enc_debug + +/* From vp9/vp9_cx_iface.c */ +#define DEFAULT_PROFILE 0 + +#define DEFAULT_RC_END_USAGE VPX_VBR +#define DEFAULT_RC_TARGET_BITRATE 256000 +#define DEFAULT_RC_MIN_QUANTIZER 4 +#define DEFAULT_RC_MAX_QUANTIZER 63 + +#define DEFAULT_RC_DROPFRAME_THRESH 0 +#define DEFAULT_RC_RESIZE_ALLOWED 0 +#define DEFAULT_RC_RESIZE_UP_THRESH 30 +#define DEFAULT_RC_RESIZE_DOWN_THRESH 60 +#define DEFAULT_RC_UNDERSHOOT_PCT 100 +#define DEFAULT_RC_OVERSHOOT_PCT 100 +#define DEFAULT_RC_BUF_SZ 6000 +#define DEFAULT_RC_BUF_INITIAL_SZ 4000 +#define DEFAULT_RC_BUF_OPTIMAL_SZ 5000 +#define DEFAULT_RC_2PASS_VBR_BIAS_PCT 50 +#define DEFAULT_RC_2PASS_VBR_MINSECTION_PCT 0 +#define DEFAULT_RC_2PASS_VBR_MAXSECTION_PCT 400 + +#define DEFAULT_KF_MODE VPX_KF_AUTO +#define DEFAULT_KF_MAX_DIST 128 + +#define DEFAULT_MULTIPASS_MODE VPX_RC_ONE_PASS +#define DEFAULT_MULTIPASS_CACHE_FILE "multipass.cache" + +#define DEFAULT_TS_NUMBER_LAYERS 1 +#define DEFAULT_TS_TARGET_BITRATE NULL +#define DEFAULT_TS_RATE_DECIMATOR NULL +#define DEFAULT_TS_PERIODICITY 0 +#define DEFAULT_TS_LAYER_ID NULL + +#define DEFAULT_ERROR_RESILIENT 0 +#define DEFAULT_LAG_IN_FRAMES 0 + +#define DEFAULT_THREADS 0 + +#define DEFAULT_H_SCALING_MODE VP8E_NORMAL +#define DEFAULT_V_SCALING_MODE VP8E_NORMAL +#define DEFAULT_CPU_USED 0 +#define DEFAULT_ENABLE_AUTO_ALT_REF FALSE +#define DEFAULT_DEADLINE VPX_DL_BEST_QUALITY +#define DEFAULT_NOISE_SENSITIVITY 0 +#define DEFAULT_SHARPNESS 0 +#define DEFAULT_STATIC_THRESHOLD 0 +#define DEFAULT_TOKEN_PARTITIONS 0 +#define DEFAULT_ARNR_MAXFRAMES 0 +#define DEFAULT_ARNR_STRENGTH 3 +#define DEFAULT_ARNR_TYPE 3 +#define DEFAULT_TUNING VP8_TUNE_PSNR +#define DEFAULT_CQ_LEVEL 10 +#define DEFAULT_MAX_INTRA_BITRATE_PCT 0 +#define DEFAULT_TIMEBASE_N 0 +#define DEFAULT_TIMEBASE_D 1 + +enum +{ + PROP_0, + PROP_RC_END_USAGE, + PROP_RC_TARGET_BITRATE, + PROP_RC_MIN_QUANTIZER, + PROP_RC_MAX_QUANTIZER, + PROP_RC_DROPFRAME_THRESH, + PROP_RC_RESIZE_ALLOWED, + PROP_RC_RESIZE_UP_THRESH, + PROP_RC_RESIZE_DOWN_THRESH, + PROP_RC_UNDERSHOOT_PCT, + PROP_RC_OVERSHOOT_PCT, + PROP_RC_BUF_SZ, + PROP_RC_BUF_INITIAL_SZ, + PROP_RC_BUF_OPTIMAL_SZ, + PROP_RC_2PASS_VBR_BIAS_PCT, + PROP_RC_2PASS_VBR_MINSECTION_PCT, + PROP_RC_2PASS_VBR_MAXSECTION_PCT, + PROP_KF_MODE, + PROP_KF_MAX_DIST, + PROP_TS_NUMBER_LAYERS, + PROP_TS_TARGET_BITRATE, + PROP_TS_RATE_DECIMATOR, + PROP_TS_PERIODICITY, + PROP_TS_LAYER_ID, + PROP_MULTIPASS_MODE, + PROP_MULTIPASS_CACHE_FILE, + PROP_ERROR_RESILIENT, + PROP_LAG_IN_FRAMES, + PROP_THREADS, + PROP_DEADLINE, + PROP_H_SCALING_MODE, + PROP_V_SCALING_MODE, + PROP_CPU_USED, + PROP_ENABLE_AUTO_ALT_REF, + PROP_NOISE_SENSITIVITY, + PROP_SHARPNESS, + PROP_STATIC_THRESHOLD, + PROP_TOKEN_PARTITIONS, + PROP_ARNR_MAXFRAMES, + PROP_ARNR_STRENGTH, + PROP_ARNR_TYPE, + PROP_TUNING, + PROP_CQ_LEVEL, + PROP_MAX_INTRA_BITRATE_PCT, + PROP_TIMEBASE +}; + +#define GST_VP9_ENC_END_USAGE_TYPE (gst_vp9_enc_end_usage_get_type()) +static GType +gst_vp9_enc_end_usage_get_type (void) +{ + static const GEnumValue values[] = { + {VPX_VBR, "Variable Bit Rate (VBR) mode", "vbr"}, + {VPX_CBR, "Constant Bit Rate (CBR) mode", "cbr"}, + {VPX_CQ, "Constant Quality Mode (CQ) mode", "cq"}, + {0, NULL, NULL} + }; + static volatile GType id = 0; + + if (g_once_init_enter ((gsize *) & id)) { + GType _id; + + _id = g_enum_register_static ("GstVP9EncEndUsage", values); + + g_once_init_leave ((gsize *) & id, _id); + } + + return id; +} + +#define GST_VP9_ENC_MULTIPASS_MODE_TYPE (gst_vp9_enc_multipass_mode_get_type()) +static GType +gst_vp9_enc_multipass_mode_get_type (void) +{ + static const GEnumValue values[] = { + {VPX_RC_ONE_PASS, "One pass encoding (default)", "one-pass"}, + {VPX_RC_FIRST_PASS, "First pass of multipass encoding", "first-pass"}, + {VPX_RC_LAST_PASS, "Last pass of multipass encoding", "last-pass"}, + {0, NULL, NULL} + }; + static volatile GType id = 0; + + if (g_once_init_enter ((gsize *) & id)) { + GType _id; + + _id = g_enum_register_static ("GstVP9EncMultipassMode", values); + + g_once_init_leave ((gsize *) & id, _id); + } + + return id; +} + +#define GST_VP9_ENC_KF_MODE_TYPE (gst_vp9_enc_kf_mode_get_type()) +static GType +gst_vp9_enc_kf_mode_get_type (void) +{ + static const GEnumValue values[] = { + {VPX_KF_AUTO, "Determine optimal placement automatically", "auto"}, + {VPX_KF_DISABLED, "Don't automatically place keyframes", "disabled"}, + {0, NULL, NULL} + }; + static volatile GType id = 0; + + if (g_once_init_enter ((gsize *) & id)) { + GType _id; + + _id = g_enum_register_static ("GstVP9EncKfMode", values); + + g_once_init_leave ((gsize *) & id, _id); + } + + return id; +} + +#define GST_VP9_ENC_TUNING_TYPE (gst_vp9_enc_tuning_get_type()) +static GType +gst_vp9_enc_tuning_get_type (void) +{ + static const GEnumValue values[] = { + {VP8_TUNE_PSNR, "Tune for PSNR", "psnr"}, + {VP8_TUNE_SSIM, "Tune for SSIM", "ssim"}, + {0, NULL, NULL} + }; + static volatile GType id = 0; + + if (g_once_init_enter ((gsize *) & id)) { + GType _id; + + _id = g_enum_register_static ("GstVP9EncTuning", values); + + g_once_init_leave ((gsize *) & id, _id); + } + + return id; +} + +#define GST_VP9_ENC_SCALING_MODE_TYPE (gst_vp9_enc_scaling_mode_get_type()) +static GType +gst_vp9_enc_scaling_mode_get_type (void) +{ + static const GEnumValue values[] = { + {VP8E_NORMAL, "Normal", "normal"}, + {VP8E_FOURFIVE, "4:5", "4:5"}, + {VP8E_THREEFIVE, "3:5", "3:5"}, + {VP8E_ONETWO, "1:2", "1:2"}, + {0, NULL, NULL} + }; + static volatile GType id = 0; + + if (g_once_init_enter ((gsize *) & id)) { + GType _id; + + _id = g_enum_register_static ("GstVP9EncScalingMode", values); + + g_once_init_leave ((gsize *) & id, _id); + } + + return id; +} + +#define GST_VP9_ENC_TOKEN_PARTITIONS_TYPE (gst_vp9_enc_token_partitions_get_type()) +static GType +gst_vp9_enc_token_partitions_get_type (void) +{ + static const GEnumValue values[] = { + {VP8_ONE_TOKENPARTITION, "One token partition", "1"}, + {VP8_TWO_TOKENPARTITION, "Two token partitions", "2"}, + {VP8_FOUR_TOKENPARTITION, "Four token partitions", "4"}, + {VP8_EIGHT_TOKENPARTITION, "Eight token partitions", "8"}, + {0, NULL, NULL} + }; + static volatile GType id = 0; + + if (g_once_init_enter ((gsize *) & id)) { + GType _id; + + _id = g_enum_register_static ("GstVP9EncTokenPartitions", values); + + g_once_init_leave ((gsize *) & id, _id); + } + + return id; +} + +#define GST_VP9_ENC_ER_FLAGS_TYPE (gst_vp9_enc_er_flags_get_type()) +static GType +gst_vp9_enc_er_flags_get_type (void) +{ + static const GFlagsValue values[] = { + {VPX_ERROR_RESILIENT_DEFAULT, "Default error resilience", "default"}, + {VPX_ERROR_RESILIENT_PARTITIONS, + "Allow partitions to be decoded independently", "partitions"}, + {0, NULL, NULL} + }; + static volatile GType id = 0; + + if (g_once_init_enter ((gsize *) & id)) { + GType _id; + + _id = g_flags_register_static ("GstVP9EncErFlags", values); + + g_once_init_leave ((gsize *) & id, _id); + } + + return id; +} + +static void gst_vp9_enc_finalize (GObject * object); +static void gst_vp9_enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_vp9_enc_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static gboolean gst_vp9_enc_start (GstVideoEncoder * encoder); +static gboolean gst_vp9_enc_stop (GstVideoEncoder * encoder); +static gboolean gst_vp9_enc_set_format (GstVideoEncoder * + video_encoder, GstVideoCodecState * state); +static gboolean gst_vp9_enc_finish (GstVideoEncoder * video_encoder); +static GstFlowReturn gst_vp9_enc_handle_frame (GstVideoEncoder * + video_encoder, GstVideoCodecFrame * frame); +static gboolean gst_vp9_enc_sink_event (GstVideoEncoder * + video_encoder, GstEvent * event); +static gboolean gst_vp9_enc_propose_allocation (GstVideoEncoder * encoder, + GstQuery * query); + +static GstStaticPadTemplate gst_vp9_enc_sink_template = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("I420")) + ); + +static GstStaticPadTemplate gst_vp9_enc_src_template = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-vp9, " "profile = (string) {0, 1, 2, 3}") + ); + +#define parent_class gst_vp9_enc_parent_class +G_DEFINE_TYPE_WITH_CODE (GstVP9Enc, gst_vp9_enc, GST_TYPE_VIDEO_ENCODER, + G_IMPLEMENT_INTERFACE (GST_TYPE_TAG_SETTER, NULL); + G_IMPLEMENT_INTERFACE (GST_TYPE_PRESET, NULL);); + +static void +gst_vp9_enc_class_init (GstVP9EncClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *element_class; + GstVideoEncoderClass *video_encoder_class; + + gobject_class = G_OBJECT_CLASS (klass); + element_class = GST_ELEMENT_CLASS (klass); + video_encoder_class = GST_VIDEO_ENCODER_CLASS (klass); + + gobject_class->set_property = gst_vp9_enc_set_property; + gobject_class->get_property = gst_vp9_enc_get_property; + gobject_class->finalize = gst_vp9_enc_finalize; + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_vp9_enc_src_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_vp9_enc_sink_template)); + + gst_element_class_set_static_metadata (element_class, + "On2 VP9 Encoder", + "Codec/Encoder/Video", + "Encode VP9 video streams", "David Schleef , " + "Sebastian Dröge "); + + video_encoder_class->start = gst_vp9_enc_start; + video_encoder_class->stop = gst_vp9_enc_stop; + video_encoder_class->handle_frame = gst_vp9_enc_handle_frame; + video_encoder_class->set_format = gst_vp9_enc_set_format; + video_encoder_class->finish = gst_vp9_enc_finish; + video_encoder_class->sink_event = gst_vp9_enc_sink_event; + video_encoder_class->propose_allocation = gst_vp9_enc_propose_allocation; + + g_object_class_install_property (gobject_class, PROP_RC_END_USAGE, + g_param_spec_enum ("end-usage", "Rate control mode", + "Rate control mode", + GST_VP9_ENC_END_USAGE_TYPE, DEFAULT_RC_END_USAGE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_TARGET_BITRATE, + g_param_spec_int ("target-bitrate", "Target bitrate", + "Target bitrate (in bits/sec)", + 0, G_MAXINT, DEFAULT_RC_TARGET_BITRATE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_MIN_QUANTIZER, + g_param_spec_int ("min-quantizer", "Minimum Quantizer", + "Minimum Quantizer (best)", + 0, 63, DEFAULT_RC_MIN_QUANTIZER, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_MAX_QUANTIZER, + g_param_spec_int ("max-quantizer", "Maximum Quantizer", + "Maximum Quantizer (worst)", + 0, 63, DEFAULT_RC_MAX_QUANTIZER, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_DROPFRAME_THRESH, + g_param_spec_int ("dropframe-threshold", "Drop Frame Threshold", + "Temporal resampling threshold (buf %)", + 0, 100, DEFAULT_RC_DROPFRAME_THRESH, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_RESIZE_ALLOWED, + g_param_spec_boolean ("resize-allowed", "Resize Allowed", + "Allow spatial resampling", + DEFAULT_RC_RESIZE_ALLOWED, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_RESIZE_UP_THRESH, + g_param_spec_int ("resize-up-threshold", "Resize Up Threshold", + "Upscale threshold (buf %)", + 0, 100, DEFAULT_RC_RESIZE_UP_THRESH, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_RESIZE_DOWN_THRESH, + g_param_spec_int ("resize-down-threshold", "Resize Down Threshold", + "Downscale threshold (buf %)", + 0, 100, DEFAULT_RC_RESIZE_DOWN_THRESH, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_UNDERSHOOT_PCT, + g_param_spec_int ("undershoot", "Undershoot PCT", + "Datarate undershoot (min) target (%)", + 0, 1000, DEFAULT_RC_UNDERSHOOT_PCT, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_OVERSHOOT_PCT, + g_param_spec_int ("overshoot", "Overshoot PCT", + "Datarate overshoot (max) target (%)", + 0, 1000, DEFAULT_RC_OVERSHOOT_PCT, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_BUF_SZ, + g_param_spec_int ("buffer-size", "Buffer size", + "Client buffer size (ms)", + 0, G_MAXINT, DEFAULT_RC_BUF_SZ, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_BUF_INITIAL_SZ, + g_param_spec_int ("buffer-initial-size", "Buffer initial size", + "Initial client buffer size (ms)", + 0, G_MAXINT, DEFAULT_RC_BUF_INITIAL_SZ, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_BUF_OPTIMAL_SZ, + g_param_spec_int ("buffer-optimal-size", "Buffer optimal size", + "Optimal client buffer size (ms)", + 0, G_MAXINT, DEFAULT_RC_BUF_OPTIMAL_SZ, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_RC_2PASS_VBR_BIAS_PCT, + g_param_spec_int ("twopass-vbr-bias", "2-pass VBR bias", + "CBR/VBR bias (0=CBR, 100=VBR)", + 0, 100, DEFAULT_RC_2PASS_VBR_BIAS_PCT, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, + PROP_RC_2PASS_VBR_MINSECTION_PCT, + g_param_spec_int ("twopass-vbr-minsection", "2-pass GOP min bitrate", + "GOP minimum bitrate (% target)", 0, G_MAXINT, + DEFAULT_RC_2PASS_VBR_MINSECTION_PCT, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, + PROP_RC_2PASS_VBR_MAXSECTION_PCT, + g_param_spec_int ("twopass-vbr-maxsection", "2-pass GOP max bitrate", + "GOP maximum bitrate (% target)", 0, G_MAXINT, + DEFAULT_RC_2PASS_VBR_MINSECTION_PCT, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_KF_MODE, + g_param_spec_enum ("keyframe-mode", "Keyframe Mode", + "Keyframe placement", + GST_VP9_ENC_KF_MODE_TYPE, DEFAULT_KF_MODE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_KF_MAX_DIST, + g_param_spec_int ("keyframe-max-dist", "Keyframe max distance", + "Maximum distance between keyframes (number of frames)", + 0, G_MAXINT, DEFAULT_KF_MAX_DIST, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_MULTIPASS_MODE, + g_param_spec_enum ("multipass-mode", "Multipass Mode", + "Multipass encode mode", + GST_VP9_ENC_MULTIPASS_MODE_TYPE, DEFAULT_MULTIPASS_MODE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_MULTIPASS_CACHE_FILE, + g_param_spec_string ("multipass-cache-file", "Multipass Cache File", + "Multipass cache file", + DEFAULT_MULTIPASS_CACHE_FILE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_TS_NUMBER_LAYERS, + g_param_spec_int ("temporal-scalability-number-layers", + "Number of coding layers", "Number of coding layers to use", 1, 5, + DEFAULT_TS_NUMBER_LAYERS, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_TS_TARGET_BITRATE, + g_param_spec_value_array ("temporal-scalability-target-bitrate", + "Coding layer target bitrates", + "Target bitrates for coding layers (one per layer, decreasing)", + g_param_spec_int ("target-bitrate", "Target bitrate", + "Target bitrate", 0, G_MAXINT, DEFAULT_RC_TARGET_BITRATE, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS), + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_TS_RATE_DECIMATOR, + g_param_spec_value_array ("temporal-scalability-rate-decimator", + "Coding layer rate decimator", + "Rate decimation factors for each layer", + g_param_spec_int ("rate-decimator", "Rate decimator", + "Rate decimator", 0, 1000000000, 0, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS), + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_TS_PERIODICITY, + g_param_spec_int ("temporal-scalability-periodicity", + "Coding layer periodicity", + "Length of sequence that defines layer membership periodicity", 0, 16, + DEFAULT_TS_PERIODICITY, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_TS_LAYER_ID, + g_param_spec_value_array ("temporal-scalability-layer-id", + "Coding layer identification", + "Sequence defining coding layer membership", + g_param_spec_int ("layer-id", "Layer ID", "Layer ID", 0, 4, 0, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS), + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_LAG_IN_FRAMES, + g_param_spec_int ("lag-in-frames", "Lag in frames", + "Maximum number of frames to lag", + 0, 25, DEFAULT_LAG_IN_FRAMES, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_ERROR_RESILIENT, + g_param_spec_flags ("error-resilient", "Error resilient", + "Error resilience flags", + GST_VP9_ENC_ER_FLAGS_TYPE, DEFAULT_ERROR_RESILIENT, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_THREADS, + g_param_spec_int ("threads", "Threads", + "Number of threads to use", + 0, 64, DEFAULT_THREADS, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_DEADLINE, + g_param_spec_int64 ("deadline", "Deadline", + "Deadline per frame (usec, 0=disabled)", + 0, G_MAXINT64, DEFAULT_DEADLINE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_H_SCALING_MODE, + g_param_spec_enum ("horizontal-scaling-mode", "Horizontal scaling mode", + "Horizontal scaling mode", + GST_VP9_ENC_SCALING_MODE_TYPE, DEFAULT_H_SCALING_MODE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_V_SCALING_MODE, + g_param_spec_enum ("vertical-scaling-mode", "Vertical scaling mode", + "Vertical scaling mode", + GST_VP9_ENC_SCALING_MODE_TYPE, DEFAULT_V_SCALING_MODE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_CPU_USED, + g_param_spec_int ("cpu-used", "CPU used", + "CPU used", + -16, 16, DEFAULT_CPU_USED, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_ENABLE_AUTO_ALT_REF, + g_param_spec_boolean ("auto-alt-ref", "Auto alt reference frames", + "Automatically generate AltRef frames", + DEFAULT_ENABLE_AUTO_ALT_REF, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_NOISE_SENSITIVITY, + g_param_spec_int ("noise-sensitivity", "Noise sensitivity", + "Noise sensisivity (frames to blur)", + 0, 6, DEFAULT_NOISE_SENSITIVITY, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_SHARPNESS, + g_param_spec_int ("sharpness", "Sharpness", + "Filter sharpness", + 0, 7, DEFAULT_SHARPNESS, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_STATIC_THRESHOLD, + g_param_spec_int ("static-threshold", "Static Threshold", + "Motion detection threshold", + 0, G_MAXINT, DEFAULT_STATIC_THRESHOLD, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_TOKEN_PARTITIONS, + g_param_spec_enum ("token-partitions", "Token partitions", + "Number of token partitions", + GST_VP9_ENC_TOKEN_PARTITIONS_TYPE, DEFAULT_TOKEN_PARTITIONS, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_ARNR_MAXFRAMES, + g_param_spec_int ("arnr-maxframes", "AltRef max frames", + "AltRef maximum number of frames", + 0, 15, DEFAULT_ARNR_MAXFRAMES, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_ARNR_STRENGTH, + g_param_spec_int ("arnr-strength", "AltRef strength", + "AltRef strength", + 0, 6, DEFAULT_ARNR_STRENGTH, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_ARNR_TYPE, + g_param_spec_int ("arnr-type", "AltRef type", + "AltRef type", + 1, 3, DEFAULT_ARNR_TYPE, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_TUNING, + g_param_spec_enum ("tuning", "Tuning", + "Tuning", + GST_VP9_ENC_TUNING_TYPE, DEFAULT_TUNING, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_CQ_LEVEL, + g_param_spec_int ("cq-level", "Constrained quality level", + "Constrained quality level", + 0, 63, DEFAULT_CQ_LEVEL, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_MAX_INTRA_BITRATE_PCT, + g_param_spec_int ("max-intra-bitrate", "Max Intra bitrate", + "Maximum Intra frame bitrate", + 0, G_MAXINT, DEFAULT_MAX_INTRA_BITRATE_PCT, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS))); + + g_object_class_install_property (gobject_class, PROP_TIMEBASE, + gst_param_spec_fraction ("timebase", "Shortest interframe time", + "Fraction of one second that is the shortest interframe time - normally left as zero which will default to the framerate", + 0, 1, G_MAXINT, 1, DEFAULT_TIMEBASE_N, DEFAULT_TIMEBASE_D, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + GST_DEBUG_CATEGORY_INIT (gst_vp9enc_debug, "vp9enc", 0, "VP9 Encoder"); +} + +static void +gst_vp9_enc_init (GstVP9Enc * gst_vp9_enc) +{ + vpx_codec_err_t status; + + GST_DEBUG_OBJECT (gst_vp9_enc, "init"); + + status = + vpx_codec_enc_config_default (&vpx_codec_vp9_cx_algo, &gst_vp9_enc->cfg, + 0); + if (status != VPX_CODEC_OK) { + GST_ERROR_OBJECT (gst_vp9_enc, + "Failed to get default encoder configuration: %s", + gst_vpx_error_name (status)); + gst_vp9_enc->have_default_config = FALSE; + } else { + gst_vp9_enc->have_default_config = TRUE; + } + + gst_vp9_enc->cfg.rc_end_usage = DEFAULT_RC_END_USAGE; + gst_vp9_enc->cfg.rc_target_bitrate = DEFAULT_RC_TARGET_BITRATE / 1000; + gst_vp9_enc->rc_target_bitrate_set = FALSE; + gst_vp9_enc->cfg.rc_min_quantizer = DEFAULT_RC_MIN_QUANTIZER; + gst_vp9_enc->cfg.rc_max_quantizer = DEFAULT_RC_MAX_QUANTIZER; + gst_vp9_enc->cfg.rc_dropframe_thresh = DEFAULT_RC_DROPFRAME_THRESH; + gst_vp9_enc->cfg.rc_resize_allowed = DEFAULT_RC_RESIZE_ALLOWED; + gst_vp9_enc->cfg.rc_resize_up_thresh = DEFAULT_RC_RESIZE_UP_THRESH; + gst_vp9_enc->cfg.rc_resize_down_thresh = DEFAULT_RC_RESIZE_DOWN_THRESH; + gst_vp9_enc->cfg.rc_undershoot_pct = DEFAULT_RC_UNDERSHOOT_PCT; + gst_vp9_enc->cfg.rc_overshoot_pct = DEFAULT_RC_OVERSHOOT_PCT; + gst_vp9_enc->cfg.rc_buf_sz = DEFAULT_RC_BUF_SZ; + gst_vp9_enc->cfg.rc_buf_initial_sz = DEFAULT_RC_BUF_INITIAL_SZ; + gst_vp9_enc->cfg.rc_buf_optimal_sz = DEFAULT_RC_BUF_OPTIMAL_SZ; + gst_vp9_enc->cfg.rc_2pass_vbr_bias_pct = DEFAULT_RC_2PASS_VBR_BIAS_PCT; + gst_vp9_enc->cfg.rc_2pass_vbr_minsection_pct = + DEFAULT_RC_2PASS_VBR_MINSECTION_PCT; + gst_vp9_enc->cfg.rc_2pass_vbr_maxsection_pct = + DEFAULT_RC_2PASS_VBR_MAXSECTION_PCT; + gst_vp9_enc->cfg.kf_mode = DEFAULT_KF_MODE; + gst_vp9_enc->cfg.kf_max_dist = DEFAULT_KF_MAX_DIST; + gst_vp9_enc->cfg.g_pass = DEFAULT_MULTIPASS_MODE; + gst_vp9_enc->multipass_cache_file = g_strdup (DEFAULT_MULTIPASS_CACHE_FILE); + gst_vp9_enc->cfg.ts_number_layers = DEFAULT_TS_NUMBER_LAYERS; + gst_vp9_enc->n_ts_target_bitrate = 0; + gst_vp9_enc->n_ts_rate_decimator = 0; + gst_vp9_enc->cfg.ts_periodicity = DEFAULT_TS_PERIODICITY; + gst_vp9_enc->n_ts_layer_id = 0; + gst_vp9_enc->cfg.g_error_resilient = DEFAULT_ERROR_RESILIENT; + gst_vp9_enc->cfg.g_lag_in_frames = DEFAULT_LAG_IN_FRAMES; + gst_vp9_enc->cfg.g_threads = DEFAULT_THREADS; + gst_vp9_enc->deadline = DEFAULT_DEADLINE; + gst_vp9_enc->h_scaling_mode = DEFAULT_H_SCALING_MODE; + gst_vp9_enc->v_scaling_mode = DEFAULT_V_SCALING_MODE; + gst_vp9_enc->cpu_used = DEFAULT_CPU_USED; + gst_vp9_enc->enable_auto_alt_ref = DEFAULT_ENABLE_AUTO_ALT_REF; + gst_vp9_enc->noise_sensitivity = DEFAULT_NOISE_SENSITIVITY; + gst_vp9_enc->sharpness = DEFAULT_SHARPNESS; + gst_vp9_enc->static_threshold = DEFAULT_STATIC_THRESHOLD; + gst_vp9_enc->token_partitions = DEFAULT_TOKEN_PARTITIONS; + gst_vp9_enc->arnr_maxframes = DEFAULT_ARNR_MAXFRAMES; + gst_vp9_enc->arnr_strength = DEFAULT_ARNR_STRENGTH; + gst_vp9_enc->arnr_type = DEFAULT_ARNR_TYPE; + gst_vp9_enc->tuning = DEFAULT_TUNING; + gst_vp9_enc->cq_level = DEFAULT_CQ_LEVEL; + gst_vp9_enc->max_intra_bitrate_pct = DEFAULT_MAX_INTRA_BITRATE_PCT; + gst_vp9_enc->timebase_n = DEFAULT_TIMEBASE_N; + gst_vp9_enc->timebase_d = DEFAULT_TIMEBASE_D; + + gst_vp9_enc->cfg.g_profile = DEFAULT_PROFILE; + + g_mutex_init (&gst_vp9_enc->encoder_lock); +} + +static void +gst_vp9_enc_finalize (GObject * object) +{ + GstVP9Enc *gst_vp9_enc; + + GST_DEBUG_OBJECT (object, "finalize"); + + g_return_if_fail (GST_IS_VP9_ENC (object)); + gst_vp9_enc = GST_VP9_ENC (object); + + g_free (gst_vp9_enc->multipass_cache_file); + gst_vp9_enc->multipass_cache_file = NULL; + + if (gst_vp9_enc->input_state) + gst_video_codec_state_unref (gst_vp9_enc->input_state); + + g_mutex_clear (&gst_vp9_enc->encoder_lock); + + G_OBJECT_CLASS (parent_class)->finalize (object); + +} + +static void +gst_vp9_enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstVP9Enc *gst_vp9_enc; + gboolean global = FALSE; + vpx_codec_err_t status; + + g_return_if_fail (GST_IS_VP9_ENC (object)); + gst_vp9_enc = GST_VP9_ENC (object); + + GST_DEBUG_OBJECT (object, "gst_vp9_enc_set_property"); + g_mutex_lock (&gst_vp9_enc->encoder_lock); + switch (prop_id) { + case PROP_RC_END_USAGE: + gst_vp9_enc->cfg.rc_end_usage = g_value_get_enum (value); + global = TRUE; + break; + case PROP_RC_TARGET_BITRATE: + gst_vp9_enc->cfg.rc_target_bitrate = g_value_get_int (value) / 1000; + gst_vp9_enc->rc_target_bitrate_set = TRUE; + global = TRUE; + break; + case PROP_RC_MIN_QUANTIZER: + gst_vp9_enc->cfg.rc_min_quantizer = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_MAX_QUANTIZER: + gst_vp9_enc->cfg.rc_max_quantizer = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_DROPFRAME_THRESH: + gst_vp9_enc->cfg.rc_dropframe_thresh = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_RESIZE_ALLOWED: + gst_vp9_enc->cfg.rc_resize_allowed = g_value_get_boolean (value); + global = TRUE; + break; + case PROP_RC_RESIZE_UP_THRESH: + gst_vp9_enc->cfg.rc_resize_up_thresh = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_RESIZE_DOWN_THRESH: + gst_vp9_enc->cfg.rc_resize_down_thresh = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_UNDERSHOOT_PCT: + gst_vp9_enc->cfg.rc_undershoot_pct = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_OVERSHOOT_PCT: + gst_vp9_enc->cfg.rc_overshoot_pct = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_BUF_SZ: + gst_vp9_enc->cfg.rc_buf_sz = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_BUF_INITIAL_SZ: + gst_vp9_enc->cfg.rc_buf_initial_sz = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_BUF_OPTIMAL_SZ: + gst_vp9_enc->cfg.rc_buf_optimal_sz = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_2PASS_VBR_BIAS_PCT: + gst_vp9_enc->cfg.rc_2pass_vbr_bias_pct = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_2PASS_VBR_MINSECTION_PCT: + gst_vp9_enc->cfg.rc_2pass_vbr_minsection_pct = g_value_get_int (value); + global = TRUE; + break; + case PROP_RC_2PASS_VBR_MAXSECTION_PCT: + gst_vp9_enc->cfg.rc_2pass_vbr_maxsection_pct = g_value_get_int (value); + global = TRUE; + break; + case PROP_KF_MODE: + gst_vp9_enc->cfg.kf_mode = g_value_get_enum (value); + global = TRUE; + break; + case PROP_KF_MAX_DIST: + gst_vp9_enc->cfg.kf_max_dist = g_value_get_int (value); + global = TRUE; + break; + case PROP_MULTIPASS_MODE: + gst_vp9_enc->cfg.g_pass = g_value_get_enum (value); + global = TRUE; + break; + case PROP_MULTIPASS_CACHE_FILE: + if (gst_vp9_enc->multipass_cache_file) + g_free (gst_vp9_enc->multipass_cache_file); + gst_vp9_enc->multipass_cache_file = g_value_dup_string (value); + break; + case PROP_TS_NUMBER_LAYERS: + gst_vp9_enc->cfg.ts_number_layers = g_value_get_int (value); + global = TRUE; + break; + case PROP_TS_TARGET_BITRATE:{ + GValueArray *va = g_value_get_boxed (value); + + memset (&gst_vp9_enc->cfg.ts_target_bitrate, 0, + sizeof (gst_vp9_enc->cfg.ts_target_bitrate)); + if (va->n_values > VPX_TS_MAX_LAYERS) { + g_warning ("%s: Only %d layers allowed at maximum", + GST_ELEMENT_NAME (gst_vp9_enc), VPX_TS_MAX_LAYERS); + } else if (va) { + gint i; + + for (i = 0; i < va->n_values; i++) + gst_vp9_enc->cfg.ts_target_bitrate[i] = + g_value_get_int (g_value_array_get_nth (va, i)); + gst_vp9_enc->n_ts_target_bitrate = va->n_values; + } else { + gst_vp9_enc->n_ts_target_bitrate = 0; + } + global = TRUE; + break; + } + case PROP_TS_RATE_DECIMATOR:{ + GValueArray *va = g_value_get_boxed (value); + + memset (&gst_vp9_enc->cfg.ts_rate_decimator, 0, + sizeof (gst_vp9_enc->cfg.ts_rate_decimator)); + if (va->n_values > VPX_TS_MAX_LAYERS) { + g_warning ("%s: Only %d layers allowed at maximum", + GST_ELEMENT_NAME (gst_vp9_enc), VPX_TS_MAX_LAYERS); + } else if (va) { + gint i; + + for (i = 0; i < va->n_values; i++) + gst_vp9_enc->cfg.ts_rate_decimator[i] = + g_value_get_int (g_value_array_get_nth (va, i)); + gst_vp9_enc->n_ts_rate_decimator = va->n_values; + } else { + gst_vp9_enc->n_ts_rate_decimator = 0; + } + global = TRUE; + break; + } + case PROP_TS_PERIODICITY: + gst_vp9_enc->cfg.ts_periodicity = g_value_get_int (value); + global = TRUE; + break; + case PROP_TS_LAYER_ID:{ + GValueArray *va = g_value_get_boxed (value); + + memset (&gst_vp9_enc->cfg.ts_layer_id, 0, + sizeof (gst_vp9_enc->cfg.ts_layer_id)); + if (va->n_values > VPX_TS_MAX_PERIODICITY) { + g_warning ("%s: Only %d sized layer sequences allowed at maximum", + GST_ELEMENT_NAME (gst_vp9_enc), VPX_TS_MAX_PERIODICITY); + } else if (va) { + gint i; + + for (i = 0; i < va->n_values; i++) + gst_vp9_enc->cfg.ts_layer_id[i] = + g_value_get_int (g_value_array_get_nth (va, i)); + gst_vp9_enc->n_ts_layer_id = va->n_values; + } else { + gst_vp9_enc->n_ts_layer_id = 0; + } + global = TRUE; + break; + } + case PROP_ERROR_RESILIENT: + gst_vp9_enc->cfg.g_error_resilient = g_value_get_flags (value); + global = TRUE; + break; + case PROP_LAG_IN_FRAMES: + gst_vp9_enc->cfg.g_lag_in_frames = g_value_get_int (value); + global = TRUE; + break; + case PROP_THREADS: + gst_vp9_enc->cfg.g_threads = g_value_get_int (value); + global = TRUE; + break; + case PROP_DEADLINE: + gst_vp9_enc->deadline = g_value_get_int64 (value); + break; + case PROP_H_SCALING_MODE: + gst_vp9_enc->h_scaling_mode = g_value_get_enum (value); + if (gst_vp9_enc->inited) { + vpx_scaling_mode_t sm; + + sm.h_scaling_mode = gst_vp9_enc->h_scaling_mode; + sm.v_scaling_mode = gst_vp9_enc->v_scaling_mode; + + status = + vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_SCALEMODE, &sm); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_SCALEMODE: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_V_SCALING_MODE: + gst_vp9_enc->v_scaling_mode = g_value_get_enum (value); + if (gst_vp9_enc->inited) { + vpx_scaling_mode_t sm; + + sm.h_scaling_mode = gst_vp9_enc->h_scaling_mode; + sm.v_scaling_mode = gst_vp9_enc->v_scaling_mode; + + status = + vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_SCALEMODE, &sm); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_SCALEMODE: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_CPU_USED: + gst_vp9_enc->cpu_used = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = + vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_CPUUSED, + gst_vp9_enc->cpu_used); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, "Failed to set VP8E_SET_CPUUSED: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_ENABLE_AUTO_ALT_REF: + gst_vp9_enc->enable_auto_alt_ref = g_value_get_boolean (value); + if (gst_vp9_enc->inited) { + status = + vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_ENABLEAUTOALTREF, + (gst_vp9_enc->enable_auto_alt_ref ? 1 : 0)); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_ENABLEAUTOALTREF: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_NOISE_SENSITIVITY: + gst_vp9_enc->noise_sensitivity = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = + vpx_codec_control (&gst_vp9_enc->encoder, + VP8E_SET_NOISE_SENSITIVITY, gst_vp9_enc->noise_sensitivity); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_NOISE_SENSITIVITY: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_SHARPNESS: + gst_vp9_enc->sharpness = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_SHARPNESS, + gst_vp9_enc->sharpness); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_SHARPNESS: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_STATIC_THRESHOLD: + gst_vp9_enc->static_threshold = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = + vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_STATIC_THRESHOLD, + gst_vp9_enc->static_threshold); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_STATIC_THRESHOLD: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_TOKEN_PARTITIONS: + gst_vp9_enc->token_partitions = g_value_get_enum (value); + if (gst_vp9_enc->inited) { + status = + vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_TOKEN_PARTITIONS, + gst_vp9_enc->token_partitions); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_TOKEN_PARTIONS: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_ARNR_MAXFRAMES: + gst_vp9_enc->arnr_maxframes = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = + vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_ARNR_MAXFRAMES, + gst_vp9_enc->arnr_maxframes); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_ARNR_MAXFRAMES: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_ARNR_STRENGTH: + gst_vp9_enc->arnr_strength = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = + vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_ARNR_STRENGTH, + gst_vp9_enc->arnr_strength); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_ARNR_STRENGTH: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_ARNR_TYPE: + gst_vp9_enc->arnr_type = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_ARNR_TYPE, + gst_vp9_enc->arnr_type); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_ARNR_TYPE: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_TUNING: + gst_vp9_enc->tuning = g_value_get_enum (value); + if (gst_vp9_enc->inited) { + status = vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_TUNING, + gst_vp9_enc->tuning); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_TUNING: %s", gst_vpx_error_name (status)); + } + } + break; + case PROP_CQ_LEVEL: + gst_vp9_enc->cq_level = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = vpx_codec_control (&gst_vp9_enc->encoder, VP8E_SET_CQ_LEVEL, + gst_vp9_enc->cq_level); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_CQ_LEVEL: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_MAX_INTRA_BITRATE_PCT: + gst_vp9_enc->max_intra_bitrate_pct = g_value_get_int (value); + if (gst_vp9_enc->inited) { + status = + vpx_codec_control (&gst_vp9_enc->encoder, + VP8E_SET_MAX_INTRA_BITRATE_PCT, gst_vp9_enc->max_intra_bitrate_pct); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (gst_vp9_enc, + "Failed to set VP8E_SET_MAX_INTRA_BITRATE_PCT: %s", + gst_vpx_error_name (status)); + } + } + break; + case PROP_TIMEBASE: + gst_vp9_enc->timebase_n = gst_value_get_fraction_numerator (value); + gst_vp9_enc->timebase_d = gst_value_get_fraction_denominator (value); + break; + default: + break; + } + + if (global &&gst_vp9_enc->inited) { + status = + vpx_codec_enc_config_set (&gst_vp9_enc->encoder, &gst_vp9_enc->cfg); + if (status != VPX_CODEC_OK) { + g_mutex_unlock (&gst_vp9_enc->encoder_lock); + GST_ELEMENT_ERROR (gst_vp9_enc, LIBRARY, INIT, + ("Failed to set encoder configuration"), ("%s", + gst_vpx_error_name (status))); + } else { + g_mutex_unlock (&gst_vp9_enc->encoder_lock); + } + } else { + g_mutex_unlock (&gst_vp9_enc->encoder_lock); + } +} + +static void +gst_vp9_enc_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstVP9Enc *gst_vp9_enc; + + g_return_if_fail (GST_IS_VP9_ENC (object)); + gst_vp9_enc = GST_VP9_ENC (object); + + g_mutex_lock (&gst_vp9_enc->encoder_lock); + switch (prop_id) { + case PROP_RC_END_USAGE: + g_value_set_enum (value, gst_vp9_enc->cfg.rc_end_usage); + break; + case PROP_RC_TARGET_BITRATE: + g_value_set_int (value, gst_vp9_enc->cfg.rc_target_bitrate * 1000); + break; + case PROP_RC_MIN_QUANTIZER: + g_value_set_int (value, gst_vp9_enc->cfg.rc_min_quantizer); + break; + case PROP_RC_MAX_QUANTIZER: + g_value_set_int (value, gst_vp9_enc->cfg.rc_max_quantizer); + break; + case PROP_RC_DROPFRAME_THRESH: + g_value_set_int (value, gst_vp9_enc->cfg.rc_dropframe_thresh); + break; + case PROP_RC_RESIZE_ALLOWED: + g_value_set_boolean (value, gst_vp9_enc->cfg.rc_resize_allowed); + break; + case PROP_RC_RESIZE_UP_THRESH: + g_value_set_int (value, gst_vp9_enc->cfg.rc_resize_up_thresh); + break; + case PROP_RC_RESIZE_DOWN_THRESH: + g_value_set_int (value, gst_vp9_enc->cfg.rc_resize_down_thresh); + break; + case PROP_RC_UNDERSHOOT_PCT: + g_value_set_int (value, gst_vp9_enc->cfg.rc_undershoot_pct); + break; + case PROP_RC_OVERSHOOT_PCT: + g_value_set_int (value, gst_vp9_enc->cfg.rc_overshoot_pct); + break; + case PROP_RC_BUF_SZ: + g_value_set_int (value, gst_vp9_enc->cfg.rc_buf_sz); + break; + case PROP_RC_BUF_INITIAL_SZ: + g_value_set_int (value, gst_vp9_enc->cfg.rc_buf_initial_sz); + break; + case PROP_RC_BUF_OPTIMAL_SZ: + g_value_set_int (value, gst_vp9_enc->cfg.rc_buf_optimal_sz); + break; + case PROP_RC_2PASS_VBR_BIAS_PCT: + g_value_set_int (value, gst_vp9_enc->cfg.rc_2pass_vbr_bias_pct); + break; + case PROP_RC_2PASS_VBR_MINSECTION_PCT: + g_value_set_int (value, gst_vp9_enc->cfg.rc_2pass_vbr_minsection_pct); + break; + case PROP_RC_2PASS_VBR_MAXSECTION_PCT: + g_value_set_int (value, gst_vp9_enc->cfg.rc_2pass_vbr_maxsection_pct); + break; + case PROP_KF_MODE: + g_value_set_enum (value, gst_vp9_enc->cfg.kf_mode); + break; + case PROP_KF_MAX_DIST: + g_value_set_int (value, gst_vp9_enc->cfg.kf_max_dist); + break; + case PROP_MULTIPASS_MODE: + g_value_set_enum (value, gst_vp9_enc->cfg.g_pass); + break; + case PROP_MULTIPASS_CACHE_FILE: + g_value_set_string (value, gst_vp9_enc->multipass_cache_file); + break; + case PROP_TS_NUMBER_LAYERS: + g_value_set_int (value, gst_vp9_enc->cfg.ts_number_layers); + break; + case PROP_TS_TARGET_BITRATE:{ + GValueArray *va; + + if (gst_vp9_enc->n_ts_target_bitrate == 0) { + g_value_set_boxed (value, NULL); + } else { + gint i; + + va = g_value_array_new (gst_vp9_enc->n_ts_target_bitrate); + for (i = 0; i < gst_vp9_enc->n_ts_target_bitrate; i++) { + GValue v = { 0, }; + + g_value_init (&v, G_TYPE_INT); + g_value_set_int (&v, gst_vp9_enc->cfg.ts_target_bitrate[i]); + g_value_array_append (va, &v); + g_value_unset (&v); + } + g_value_set_boxed (value, va); + g_value_array_free (va); + } + break; + } + case PROP_TS_RATE_DECIMATOR:{ + GValueArray *va; + + if (gst_vp9_enc->n_ts_rate_decimator == 0) { + g_value_set_boxed (value, NULL); + } else { + gint i; + + va = g_value_array_new (gst_vp9_enc->n_ts_rate_decimator); + for (i = 0; i < gst_vp9_enc->n_ts_rate_decimator; i++) { + GValue v = { 0, }; + + g_value_init (&v, G_TYPE_INT); + g_value_set_int (&v, gst_vp9_enc->cfg.ts_rate_decimator[i]); + g_value_array_append (va, &v); + g_value_unset (&v); + } + g_value_set_boxed (value, va); + g_value_array_free (va); + } + break; + } + case PROP_TS_PERIODICITY: + g_value_set_int (value, gst_vp9_enc->cfg.ts_periodicity); + break; + case PROP_TS_LAYER_ID:{ + GValueArray *va; + + if (gst_vp9_enc->n_ts_layer_id == 0) { + g_value_set_boxed (value, NULL); + } else { + gint i; + + va = g_value_array_new (gst_vp9_enc->n_ts_layer_id); + for (i = 0; i < gst_vp9_enc->n_ts_layer_id; i++) { + GValue v = { 0, }; + + g_value_init (&v, G_TYPE_INT); + g_value_set_int (&v, gst_vp9_enc->cfg.ts_layer_id[i]); + g_value_array_append (va, &v); + g_value_unset (&v); + } + g_value_set_boxed (value, va); + g_value_array_free (va); + } + break; + } + case PROP_ERROR_RESILIENT: + g_value_set_flags (value, gst_vp9_enc->cfg.g_error_resilient); + break; + case PROP_LAG_IN_FRAMES: + g_value_set_int (value, gst_vp9_enc->cfg.g_lag_in_frames); + break; + case PROP_THREADS: + g_value_set_int (value, gst_vp9_enc->cfg.g_threads); + break; + case PROP_DEADLINE: + g_value_set_int64 (value, gst_vp9_enc->deadline); + break; + case PROP_H_SCALING_MODE: + g_value_set_enum (value, gst_vp9_enc->h_scaling_mode); + break; + case PROP_V_SCALING_MODE: + g_value_set_enum (value, gst_vp9_enc->v_scaling_mode); + break; + case PROP_CPU_USED: + g_value_set_int (value, gst_vp9_enc->cpu_used); + break; + case PROP_ENABLE_AUTO_ALT_REF: + g_value_set_boolean (value, gst_vp9_enc->enable_auto_alt_ref); + break; + case PROP_NOISE_SENSITIVITY: + g_value_set_int (value, gst_vp9_enc->noise_sensitivity); + break; + case PROP_SHARPNESS: + g_value_set_int (value, gst_vp9_enc->sharpness); + break; + case PROP_STATIC_THRESHOLD: + g_value_set_int (value, gst_vp9_enc->static_threshold); + break; + case PROP_TOKEN_PARTITIONS: + g_value_set_enum (value, gst_vp9_enc->token_partitions); + break; + case PROP_ARNR_MAXFRAMES: + g_value_set_int (value, gst_vp9_enc->arnr_maxframes); + break; + case PROP_ARNR_STRENGTH: + g_value_set_int (value, gst_vp9_enc->arnr_strength); + break; + case PROP_ARNR_TYPE: + g_value_set_int (value, gst_vp9_enc->arnr_type); + break; + case PROP_TUNING: + g_value_set_enum (value, gst_vp9_enc->tuning); + break; + case PROP_CQ_LEVEL: + g_value_set_int (value, gst_vp9_enc->cq_level); + break; + case PROP_MAX_INTRA_BITRATE_PCT: + g_value_set_int (value, gst_vp9_enc->max_intra_bitrate_pct); + break; + case PROP_TIMEBASE: + gst_value_set_fraction (value, gst_vp9_enc->timebase_n, + gst_vp9_enc->timebase_d); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } + + g_mutex_unlock (&gst_vp9_enc->encoder_lock); +} + +static gboolean +gst_vp9_enc_start (GstVideoEncoder * video_encoder) +{ + GstVP9Enc *encoder = GST_VP9_ENC (video_encoder); + + GST_DEBUG_OBJECT (video_encoder, "start"); + + if (!encoder->have_default_config) { + GST_ELEMENT_ERROR (encoder, LIBRARY, INIT, + ("Failed to get default encoder configuration"), (NULL)); + return FALSE; + } + + return TRUE; +} + +static gboolean +gst_vp9_enc_stop (GstVideoEncoder * video_encoder) +{ + GstVP9Enc *encoder; + + GST_DEBUG_OBJECT (video_encoder, "stop"); + + encoder = GST_VP9_ENC (video_encoder); + + g_mutex_lock (&encoder->encoder_lock); + if (encoder->inited) { + vpx_codec_destroy (&encoder->encoder); + encoder->inited = FALSE; + } + + if (encoder->first_pass_cache_content) { + g_byte_array_free (encoder->first_pass_cache_content, TRUE); + encoder->first_pass_cache_content = NULL; + } + + if (encoder->cfg.rc_twopass_stats_in.buf) { + g_free (encoder->cfg.rc_twopass_stats_in.buf); + encoder->cfg.rc_twopass_stats_in.buf = NULL; + encoder->cfg.rc_twopass_stats_in.sz = 0; + } + g_mutex_unlock (&encoder->encoder_lock); + + gst_tag_setter_reset_tags (GST_TAG_SETTER (encoder)); + + return TRUE; +} + +static gint +gst_vp9_enc_get_downstream_profile (GstVP9Enc * encoder) +{ + GstCaps *allowed; + GstStructure *s; + gint profile = DEFAULT_PROFILE; + + allowed = gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (encoder)); + if (allowed) { + allowed = gst_caps_truncate (allowed); + s = gst_caps_get_structure (allowed, 0); + if (gst_structure_has_field (s, "profile")) { + const GValue *v = gst_structure_get_value (s, "profile"); + const gchar *profile_str = NULL; + + if (GST_VALUE_HOLDS_LIST (v) && gst_value_list_get_size (v) > 0) { + profile_str = g_value_get_string (gst_value_list_get_value (v, 0)); + } else if (G_VALUE_HOLDS_STRING (v)) { + profile_str = g_value_get_string (v); + } + + if (profile_str) { + gchar *endptr = NULL; + + profile = g_ascii_strtoull (profile_str, &endptr, 10); + if (*endptr != '\0' || profile < 0 || profile > 3) { + GST_ERROR_OBJECT (encoder, "Invalid profile '%s'", profile_str); + profile = DEFAULT_PROFILE; + } + } + } + gst_caps_unref (allowed); + } + + GST_DEBUG_OBJECT (encoder, "Using profile %d", profile); + + return profile; +} + +static gboolean +gst_vp9_enc_set_format (GstVideoEncoder * video_encoder, + GstVideoCodecState * state) +{ + GstVP9Enc *encoder; + vpx_codec_err_t status; + vpx_image_t *image; + GstCaps *caps; + gboolean ret = TRUE; + GstVideoInfo *info = &state->info; + GstVideoCodecState *output_state; + gchar *profile_str; + + encoder = GST_VP9_ENC (video_encoder); + GST_DEBUG_OBJECT (video_encoder, "set_format"); + + if (encoder->inited) { + GST_DEBUG_OBJECT (video_encoder, "refusing renegotiation"); + return FALSE; + } + + g_mutex_lock (&encoder->encoder_lock); + encoder->cfg.g_profile = gst_vp9_enc_get_downstream_profile (encoder); + + /* Scale default bitrate to our size */ + if (!encoder->rc_target_bitrate_set) + encoder->cfg.rc_target_bitrate = + gst_util_uint64_scale (DEFAULT_RC_TARGET_BITRATE, + GST_VIDEO_INFO_WIDTH (info) * GST_VIDEO_INFO_HEIGHT (info), + 320 * 240 * 1000); + + encoder->cfg.g_w = GST_VIDEO_INFO_WIDTH (info); + encoder->cfg.g_h = GST_VIDEO_INFO_HEIGHT (info); + + if (encoder->timebase_n != 0 && encoder->timebase_d != 0) { + GST_DEBUG_OBJECT (video_encoder, "Using timebase configuration"); + encoder->cfg.g_timebase.num = encoder->timebase_n; + encoder->cfg.g_timebase.den = encoder->timebase_d; + } else if (GST_VIDEO_INFO_FPS_D (info) != 0 + && GST_VIDEO_INFO_FPS_N (info) != 0) { + /* GstVideoInfo holds either the framerate or max-framerate (if framerate + * is 0) in FPS so this will be used if max-framerate or framerate + * is set */ + GST_DEBUG_OBJECT (video_encoder, "Setting timebase from framerate"); + encoder->cfg.g_timebase.num = GST_VIDEO_INFO_FPS_D (info); + encoder->cfg.g_timebase.den = GST_VIDEO_INFO_FPS_N (info); + } else { + /* Zero framerate and max-framerate but still need to setup the timebase to avoid + * a divide by zero error. Presuming the lowest common denominator will be RTP - + * VP9 payload draft states clock rate of 90000 which should work for anyone where + * FPS < 90000 (shouldn't be too many cases where it's higher) though wouldn't be optimal. RTP specification + * http://tools.ietf.org/html/draft-ietf-payload-vp9-01 section 6.3.1 */ + GST_WARNING_OBJECT (encoder, + "No timebase and zero framerate setting timebase to 1/90000"); + encoder->cfg.g_timebase.num = 1; + encoder->cfg.g_timebase.den = 90000; + } + + if (encoder->cfg.g_pass == VPX_RC_FIRST_PASS) { + encoder->first_pass_cache_content = g_byte_array_sized_new (4096); + } else if (encoder->cfg.g_pass == VPX_RC_LAST_PASS) { + GError *err = NULL; + + if (!encoder->multipass_cache_file) { + GST_ELEMENT_ERROR (encoder, RESOURCE, OPEN_READ, + ("No multipass cache file provided"), (NULL)); + g_mutex_unlock (&encoder->encoder_lock); + return FALSE; + } + + if (!g_file_get_contents (encoder->multipass_cache_file, + (gchar **) & encoder->cfg.rc_twopass_stats_in.buf, + &encoder->cfg.rc_twopass_stats_in.sz, &err)) { + GST_ELEMENT_ERROR (encoder, RESOURCE, OPEN_READ, + ("Failed to read multipass cache file provided"), ("%s", + err->message)); + g_error_free (err); + g_mutex_unlock (&encoder->encoder_lock); + return FALSE; + } + } + + status = vpx_codec_enc_init (&encoder->encoder, &vpx_codec_vp9_cx_algo, + &encoder->cfg, 0); + if (status != VPX_CODEC_OK) { + GST_ELEMENT_ERROR (encoder, LIBRARY, INIT, + ("Failed to initialize encoder"), ("%s", gst_vpx_error_name (status))); + g_mutex_unlock (&encoder->encoder_lock); + return FALSE; + } + + /* FIXME: Disabled for now, does not work with VP9 */ +#if 0 + { + vpx_scaling_mode_t sm; + + sm.h_scaling_mode = encoder->h_scaling_mode; + sm.v_scaling_mode = encoder->v_scaling_mode; + + status = vpx_codec_control (&encoder->encoder, VP8E_SET_SCALEMODE, &sm); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, "Failed to set VP8E_SET_SCALEMODE: %s", + gst_vpx_error_name (status)); + } + } +#endif + + status = + vpx_codec_control (&encoder->encoder, VP8E_SET_CPUUSED, + encoder->cpu_used); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, "Failed to set VP8E_SET_CPUUSED: %s", + gst_vpx_error_name (status)); + } + + status = + vpx_codec_control (&encoder->encoder, VP8E_SET_ENABLEAUTOALTREF, + (encoder->enable_auto_alt_ref ? 1 : 0)); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_ENABLEAUTOALTREF: %s", + gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_NOISE_SENSITIVITY, + encoder->noise_sensitivity); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_NOISE_SENSITIVITY: %s", + gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_SHARPNESS, + encoder->sharpness); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_SHARPNESS: %s", gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_STATIC_THRESHOLD, + encoder->static_threshold); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_STATIC_THRESHOLD: %s", + gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_TOKEN_PARTITIONS, + encoder->token_partitions); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_TOKEN_PARTIONS: %s", + gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_ARNR_MAXFRAMES, + encoder->arnr_maxframes); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_ARNR_MAXFRAMES: %s", + gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_ARNR_STRENGTH, + encoder->arnr_strength); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_ARNR_STRENGTH: %s", + gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_ARNR_TYPE, + encoder->arnr_type); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_ARNR_TYPE: %s", gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_TUNING, + encoder->tuning); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_TUNING: %s", gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_CQ_LEVEL, + encoder->cq_level); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_CQ_LEVEL: %s", gst_vpx_error_name (status)); + } + status = vpx_codec_control (&encoder->encoder, VP8E_SET_MAX_INTRA_BITRATE_PCT, + encoder->max_intra_bitrate_pct); + if (status != VPX_CODEC_OK) { + GST_WARNING_OBJECT (encoder, + "Failed to set VP8E_SET_MAX_INTRA_BITRATE_PCT: %s", + gst_vpx_error_name (status)); + } + + if (GST_VIDEO_INFO_FPS_D (info) == 0 || GST_VIDEO_INFO_FPS_N (info) == 0) { + gst_video_encoder_set_latency (video_encoder, GST_CLOCK_TIME_NONE, + GST_CLOCK_TIME_NONE); + } else { + gst_video_encoder_set_latency (video_encoder, 0, + gst_util_uint64_scale (encoder->cfg.g_lag_in_frames, + GST_VIDEO_INFO_FPS_D (info) * GST_SECOND, + GST_VIDEO_INFO_FPS_N (info))); + } + encoder->inited = TRUE; + + /* Store input state */ + if (encoder->input_state) + gst_video_codec_state_unref (encoder->input_state); + encoder->input_state = gst_video_codec_state_ref (state); + + /* prepare cached image buffer setup */ + image = &encoder->image; + memset (image, 0, sizeof (*image)); + + image->fmt = VPX_IMG_FMT_I420; + image->bps = 12; + image->x_chroma_shift = image->y_chroma_shift = 1; + image->w = image->d_w = GST_VIDEO_INFO_WIDTH (info); + image->h = image->d_h = GST_VIDEO_INFO_HEIGHT (info); + + image->stride[VPX_PLANE_Y] = GST_VIDEO_INFO_COMP_STRIDE (info, 0); + image->stride[VPX_PLANE_U] = GST_VIDEO_INFO_COMP_STRIDE (info, 1); + image->stride[VPX_PLANE_V] = GST_VIDEO_INFO_COMP_STRIDE (info, 2); + + profile_str = g_strdup_printf ("%d", encoder->cfg.g_profile); + caps = gst_caps_new_simple ("video/x-vp9", + "profile", G_TYPE_STRING, profile_str, NULL); + g_free (profile_str); + + g_mutex_unlock (&encoder->encoder_lock); + + output_state = + gst_video_encoder_set_output_state (video_encoder, caps, state); + gst_video_codec_state_unref (output_state); + + gst_video_encoder_negotiate (GST_VIDEO_ENCODER (encoder)); + + return ret; +} + +static GstFlowReturn +gst_vp9_enc_process (GstVP9Enc * encoder) +{ + vpx_codec_iter_t iter = NULL; + const vpx_codec_cx_pkt_t *pkt; + GstVideoEncoder *video_encoder; + GstVideoCodecFrame *frame; + GstFlowReturn ret = GST_FLOW_OK; + + video_encoder = GST_VIDEO_ENCODER (encoder); + + g_mutex_lock (&encoder->encoder_lock); + pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter); + while (pkt != NULL) { + GstBuffer *buffer; + gboolean invisible; + + GST_DEBUG_OBJECT (encoder, "packet %u type %d", (guint) pkt->data.frame.sz, + pkt->kind); + + if (pkt->kind == VPX_CODEC_STATS_PKT + && encoder->cfg.g_pass == VPX_RC_FIRST_PASS) { + GST_LOG_OBJECT (encoder, "handling STATS packet"); + + g_byte_array_append (encoder->first_pass_cache_content, + pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz); + + frame = gst_video_encoder_get_oldest_frame (video_encoder); + if (frame != NULL) { + buffer = gst_buffer_new (); + GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_LIVE); + frame->output_buffer = buffer; + g_mutex_unlock (&encoder->encoder_lock); + ret = gst_video_encoder_finish_frame (video_encoder, frame); + g_mutex_lock (&encoder->encoder_lock); + } + + pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter); + continue; + } else if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) { + GST_LOG_OBJECT (encoder, "non frame pkt: %d", pkt->kind); + pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter); + continue; + } + + invisible = (pkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE) != 0; + frame = gst_video_encoder_get_oldest_frame (video_encoder); + g_assert (frame != NULL); + if ((pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0) + GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame); + else + GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame); + + /* FIXME : It would be nice to avoid the memory copy ... */ + buffer = + gst_buffer_new_wrapped (g_memdup (pkt->data.frame.buf, + pkt->data.frame.sz), pkt->data.frame.sz); + + if (invisible) { + g_mutex_unlock (&encoder->encoder_lock); + ret = gst_pad_push (GST_VIDEO_ENCODER_SRC_PAD (encoder), buffer); + g_mutex_lock (&encoder->encoder_lock); + gst_video_codec_frame_unref (frame); + } else { + frame->output_buffer = buffer; + g_mutex_unlock (&encoder->encoder_lock); + ret = gst_video_encoder_finish_frame (video_encoder, frame); + g_mutex_lock (&encoder->encoder_lock); + } + + pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter); + } + g_mutex_unlock (&encoder->encoder_lock); + + return ret; +} + +static GstFlowReturn +gst_vp9_enc_finish (GstVideoEncoder * video_encoder) +{ + GstVP9Enc *encoder; + int flags = 0; + vpx_codec_err_t status; + + GST_DEBUG_OBJECT (video_encoder, "finish"); + + encoder = GST_VP9_ENC (video_encoder); + + g_mutex_lock (&encoder->encoder_lock); + status = + vpx_codec_encode (&encoder->encoder, NULL, encoder->n_frames, 1, flags, + encoder->deadline); + g_mutex_unlock (&encoder->encoder_lock); + if (status != 0) { + GST_ERROR_OBJECT (encoder, "encode returned %d %s", status, + gst_vpx_error_name (status)); + return GST_FLOW_ERROR; + } + + /* dispatch remaining frames */ + gst_vp9_enc_process (encoder); + + if (encoder->cfg.g_pass == VPX_RC_FIRST_PASS && encoder->multipass_cache_file) { + GError *err = NULL; + + if (!g_file_set_contents (encoder->multipass_cache_file, + (const gchar *) encoder->first_pass_cache_content->data, + encoder->first_pass_cache_content->len, &err)) { + GST_ELEMENT_ERROR (encoder, RESOURCE, WRITE, (NULL), + ("Failed to write multipass cache file: %s", err->message)); + g_error_free (err); + } + } + + return GST_FLOW_OK; +} + +static vpx_image_t * +gst_vp9_enc_buffer_to_image (GstVP9Enc * enc, GstVideoFrame * frame) +{ + vpx_image_t *image = g_slice_new (vpx_image_t); + + memcpy (image, &enc->image, sizeof (*image)); + + image->planes[VPX_PLANE_Y] = GST_VIDEO_FRAME_COMP_DATA (frame, 0); + image->planes[VPX_PLANE_U] = GST_VIDEO_FRAME_COMP_DATA (frame, 1); + image->planes[VPX_PLANE_V] = GST_VIDEO_FRAME_COMP_DATA (frame, 2); + + image->stride[VPX_PLANE_Y] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0); + image->stride[VPX_PLANE_U] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 1); + image->stride[VPX_PLANE_V] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 2); + + return image; +} + +static GstFlowReturn +gst_vp9_enc_handle_frame (GstVideoEncoder * video_encoder, + GstVideoCodecFrame * frame) +{ + GstVP9Enc *encoder; + vpx_codec_err_t status; + int flags = 0; + vpx_image_t *image; + GstVideoFrame vframe; + + GST_DEBUG_OBJECT (video_encoder, "handle_frame"); + + encoder = GST_VP9_ENC (video_encoder); + + encoder->n_frames++; + + GST_DEBUG_OBJECT (video_encoder, "size %d %d", + GST_VIDEO_INFO_WIDTH (&encoder->input_state->info), + GST_VIDEO_INFO_HEIGHT (&encoder->input_state->info)); + + gst_video_frame_map (&vframe, &encoder->input_state->info, + frame->input_buffer, GST_MAP_READ); + image = gst_vp9_enc_buffer_to_image (encoder, &vframe); + + if (GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME (frame)) { + flags |= VPX_EFLAG_FORCE_KF; + } + + g_mutex_lock (&encoder->encoder_lock); + status = vpx_codec_encode (&encoder->encoder, image, + encoder->n_frames, 1, flags, encoder->deadline); + g_mutex_unlock (&encoder->encoder_lock); + gst_video_frame_unmap (&vframe); + + if (status != 0) { + GST_ELEMENT_ERROR (encoder, LIBRARY, ENCODE, + ("Failed to encode frame"), ("%s", gst_vpx_error_name (status))); + return FALSE; + } + gst_video_codec_frame_unref (frame); + return gst_vp9_enc_process (encoder); +} + +static gboolean +gst_vp9_enc_sink_event (GstVideoEncoder * benc, GstEvent * event) +{ + GstVP9Enc *enc = GST_VP9_ENC (benc); + + /* FIXME : Move this to base encoder class */ + + if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) { + GstTagList *list; + GstTagSetter *setter = GST_TAG_SETTER (enc); + const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter); + + gst_event_parse_tag (event, &list); + gst_tag_setter_merge_tags (setter, list, mode); + } + + /* just peeked, baseclass handles the rest */ + return GST_VIDEO_ENCODER_CLASS (parent_class)->sink_event (benc, event); +} + +static gboolean +gst_vp9_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); +} + +#endif /* HAVE_VP9_ENCODER */ diff --git a/ext/vpx/gstvp9enc.h b/ext/vpx/gstvp9enc.h new file mode 100644 index 0000000..8026d58 --- /dev/null +++ b/ext/vpx/gstvp9enc.h @@ -0,0 +1,113 @@ +/* VP9 + * Copyright (C) 2006 David Schleef + * Copyright (C) 2010 Entropy Wave Inc + * Copyright (C) 2010-2013 Sebastian Dröge + * + * 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_VP9_ENC_H__ +#define __GST_VP9_ENC_H__ + +#include +#include + +/* FIXME: Undef HAVE_CONFIG_H because vpx_codec.h uses it, + * which causes compilation failures */ +#ifdef HAVE_CONFIG_H +#undef HAVE_CONFIG_H +#endif + +#include +#include + +G_BEGIN_DECLS + +#define GST_TYPE_VP9_ENC \ + (gst_vp9_enc_get_type()) +#define GST_VP9_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VP9_ENC,GstVP9Enc)) +#define GST_VP9_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VP9_ENC,GstVP9EncClass)) +#define GST_IS_VP9_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VP9_ENC)) +#define GST_IS_VP9_ENC_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VP9_ENC)) + +typedef struct _GstVP9Enc GstVP9Enc; +typedef struct _GstVP9EncClass GstVP9EncClass; + +struct _GstVP9Enc +{ + GstVideoEncoder base_video_encoder; + + /* < private > */ + vpx_codec_ctx_t encoder; + GMutex encoder_lock; + + /* properties */ + vpx_codec_enc_cfg_t cfg; + gboolean have_default_config; + gboolean rc_target_bitrate_set; + gint n_ts_target_bitrate; + gint n_ts_rate_decimator; + gint n_ts_layer_id; + /* Global two-pass options */ + gchar *multipass_cache_file; + GByteArray *first_pass_cache_content; + + /* Encode parameter */ + gint64 deadline; + + /* Controls */ + VPX_SCALING_MODE h_scaling_mode; + VPX_SCALING_MODE v_scaling_mode; + int cpu_used; + gboolean enable_auto_alt_ref; + unsigned int noise_sensitivity; + unsigned int sharpness; + unsigned int static_threshold; + vp8e_token_partitions token_partitions; + unsigned int arnr_maxframes; + unsigned int arnr_strength; + unsigned int arnr_type; + vp8e_tuning tuning; + unsigned int cq_level; + unsigned int max_intra_bitrate_pct; + /* Timebase - a value of 0 will use the framerate */ + unsigned int timebase_n; + unsigned int timebase_d; + + /* state */ + gboolean inited; + + vpx_image_t image; + + int n_frames; + + GstVideoCodecState *input_state; +}; + +struct _GstVP9EncClass +{ + GstVideoEncoderClass base_video_encoder_class; +}; + +GType gst_vp9_enc_get_type (void); + +G_END_DECLS + +#endif /* __GST_VP9_ENC_H__ */ diff --git a/ext/vpx/plugin.c b/ext/vpx/plugin.c index 149cac3..4f04efa 100644 --- a/ext/vpx/plugin.c +++ b/ext/vpx/plugin.c @@ -27,6 +27,8 @@ #include "gstvp8dec.h" #include "gstvp8enc.h" +#include "gstvp9dec.h" +#include "gstvp9enc.h" static gboolean plugin_init (GstPlugin * plugin) @@ -41,6 +43,16 @@ plugin_init (GstPlugin * plugin) gst_vp8_enc_get_type ()); #endif +#ifdef HAVE_VP9_DECODER + gst_element_register (plugin, "vp9dec", GST_RANK_PRIMARY, + gst_vp9_dec_get_type ()); +#endif + +#ifdef HAVE_VP9_ENCODER + gst_element_register (plugin, "vp9enc", GST_RANK_PRIMARY, + gst_vp9_enc_get_type ()); +#endif + return TRUE; } -- 2.7.4