Release 1.17.11.17.1

6 files changed, 1098 insertions, 1241 deletions

diff --git a/ChangeLog b/ChangeLog
index c9c160a..8210bf2 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,452 @@
+=== release 1.17.1 ===
+
+2020-06-19 19:24:14 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* ChangeLog:
+	* NEWS:
+	* RELEASE:
+	* gst-libav.doap:
+	* meson.build:
+	  Release 1.17.1
+
+2020-06-09 15:33:51 -0400  Thibault Saunier <tsaunier@igalia.com>
+
+	* docs/gst_plugins_cache.json:
+	  docs: Update plugins cache
+
+2020-06-08 09:44:43 -0400  Thibault Saunier <tsaunier@igalia.com>
+
+	* docs/gst_plugins_cache.json:
+	  docs: Update plugins cache
+
+2020-06-06 00:43:02 +0200  Mathieu Duponchelle <mathieu@centricular.com>
+
+	* ext/libav/gstavcfg.c:
+	* ext/libav/gstavdeinterlace.c:
+	* ext/libav/gstavviddec.c:
+	* ext/libav/gstavvidenc.c:
+	  plugins: uddate gst_type_mark_as_plugin_api() calls
+
+2020-06-03 18:35:32 -0400  Thibault Saunier <tsaunier@igalia.com>
+
+	* docs/meson.build:
+	  doc: Require hotdoc >= 0.11.0
+
+2020-05-27 16:02:45 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* docs/gst_plugins_cache.json:
+	  docs: Update gst_plugins_cache.json
+
+2020-05-31 10:02:12 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavcfg.c:
+	* ext/libav/gstavdeinterlace.c:
+	* ext/libav/gstavviddec.c:
+	* ext/libav/gstavvidenc.c:
+	  plugins: Use gst_type_mark_as_plugin_api() for all non-element plugin types
+
+2020-05-31 09:59:29 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavaudenc.c:
+	* ext/libav/gstavcodecmap.c:
+	* ext/libav/gstavcodecmap.h:
+	  avcodecmap: Remove unused GstFFMpegCompliance type
+
+2020-05-27 16:30:41 +0200  Mathieu Duponchelle <mathieu@centricular.com>
+
+	* ext/libav/gstavdemux.c:
+	  avdemux: update the context we use to determine stream's caps
+	  The discovered frame rate is only available on the AVStream
+	  itself. Updating the temporary context framerate before
+	  building caps from it seems like a pretty non-intrusive approach.
+	  Fixes #75
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-libav/-/merge_requests/74>
+
+2020-05-27 16:29:27 +0200  Mathieu Duponchelle <mathieu@centricular.com>
+
+	* ext/libav/gstavcodecmap.c:
+	  avcodecmap: use framerate instead of time_base when decoding
+	  Documentation for AVCodecContext::time_base:
+	  > decoding: the use of this field for decoding is deprecated.
+	  > Use framerate instead.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-libav/-/merge_requests/74>
+
+2020-05-09 15:20:00 +0200  Matej Knopp <matej.knopp@gmail.com>
+
+	* ext/libav/gstavaudenc.h:
+	* ext/libav/gstavcodecmap.h:
+	* ext/libav/gstavviddec.h:
+	  gstlibav: minor fixes for header files
+	  Move G_BEGIN_DECLS below includes and add missing include
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-libav/-/merge_requests/71>
+
+2020-05-08 19:16:41 +0200  Matej Knopp <matej.knopp@gmail.com>
+
+	* ext/libav/gstavviddec.c:
+	  gstavviddec: only set range when actually reported by avcodec
+	  otherwise we get incomplete colorimetry that video-info complains about
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-libav/-/merge_requests/70>
+
+2020-04-30 18:12:19 +0530  Nirbheek Chauhan <nirbheek@centricular.com>
+
+	* README:
+	* README.md:
+	  README: Convert to markdown, clarify licensing
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-libav/-/merge_requests/68>
+
+2020-04-30 17:13:00 +0530  Nirbheek Chauhan <nirbheek@centricular.com>
+
+	* COPYING:
+	* COPYING.LIB:
+	  All code in this repository is now LGPL-2.1+
+	  Starting with 1.17, we will not ship a copy of FFmpeg in our release
+	  tarballs, and all the remaining code is LGPL2.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-libav/-/merge_requests/68>
+
+2020-04-15 15:00:02 +0800  Haihao Xiang <haihao.xiang@intel.com>
+
+	* ext/libav/gstavmux.c:
+	  avmux: avoid to use unintialized variable
+	  Without this fix, running the command below will get an error randomly.
+	  Example:
+	  gst-launch-1.0 videotestsrc ! vp9enc ! avmux_ivf ! fakesink
+	  ERROR: pipeline doesn't want to preroll.
+	  0:00:02.388528491 30148 0x5601b424a370 ERROR                  libav :0::
+	  Tag [1]V[0][0] incompatible with output codec id '167' (VP90)
+
+2020-03-11 18:26:39 +0900  Seungha Yang <seungha@centricular.com>
+
+	* ext/libav/gstavviddec.c:
+	  avviddec: Update for video-hdr struct change
+	  See the change of -base https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/-/merge_requests/594
+
+2020-01-27 14:21:48 -0800  Julien Isorce <jisorce@oblong.com>
+
+	* ext/libav/gstavvidenc.c:
+	  avvidenc: handle GST_VIDEO_MULTIVIEW_MODE_MONO
+	  Otherwise videotestsrc ! avenc_libx265 ! fakesink
+	  outputs `Unsupported multiview mode - no mapping in libav`
+
+2020-01-24 16:14:28 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavcodecmap.c:
+	  avcodecmap: Add some more comments about the assumptions in the ffmpeg code about H264/H265/AAC
+
+2020-01-24 13:04:46 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavcodecmap.c:
+	  avdemux: Only set stream-format for H264/H265/AAC when we have a context
+	  Otherwise we don't know yet whether we'll have extradata/codec_data, so
+	  can't decide on the stream-format yet.
+
+2020-01-15 14:36:19 +0800  Haihao Xiang <haihao.xiang@intel.com>
+
+	* ext/libav/gstavcodecmap.c:
+	  avivf_mux: support VP9 and AV1
+	  Besides vp8, ff_ivf_muxer supports VP9 and AV1
+
+2020-01-23 10:03:40 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavcodecmap.c:
+	  avcodecmap: Set AAC/H264/H265 stream-format for demuxer/encoder situations if no codec_data is provided
+	  This fixes output of the above formats from demuxers.
+
+2020-01-23 09:45:59 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavdemux.c:
+	  avdemux: Pass the URI from the URI query to avformat_open_input()
+	  Some demuxers make use of it in various ways, for example the HLS
+	  demuxer.
+
+2019-12-19 17:58:56 +0100  Alicia Boya García <ntrrgc@gmail.com>
+
+	* ext/libav/gstavviddec.c:
+	  gstavviddec: Limit default number of decoder threads
+	  When the `max-threads` property is not specified, GStreamer defaults to
+	  the amount of CPU threads in the system.
+	  The number of threads used in avdec has a direct impact on the latency
+	  of the decoder, which is of as many frames as threads. Therefore, big
+	  numbers of threads can make latency levels that can be problematic in
+	  some applications.
+	  For this reason, ffmpeg emits a warning when more than 16 threads are
+	  requested.
+	  This patch limits the default number of threads to 16. This affects only
+	  computers with more than 16 CPU threads when using avviddec without
+	  setting `max-threads`.
+
+2019-12-02 19:06:04 +0000  Tim-Philipp Müller <tim@centricular.com>
+
+	* pkgconfig/gstreamer-plugins-libav-uninstalled.pc.in:
+	  pkgconfig: remove unused file
+	  Was never hooked up to meson build it seems, and only ever used
+	  by the uninstalled autotools dev env to locate gst-libav plugins
+	  for use in unit tests in other modules.
+
+2019-11-29 09:25:24 +0100  Edward Hervey <edward@centricular.com>
+
+	* ext/libav/gstavvidenc.c:
+	  avvidenc: Fix error propagation
+	  Instead of returning the default return value (GST_FLOW_OK), actually
+	  return an error one (res vs ret).
+
+2019-11-04 15:39:59 +0100  Kevin JOLY <kevin.joly@heig-vd.ch>
+
+	* ext/libav/gstavdemux.c:
+	  avdemux: Fix segmentation fault if long_name is NULL
+	  Some plugins (like libcdio) registers empty long_name field. Calling strncmp on this field leads to a segmentation fault.
+	  Signed-off-by: Kevin Joly <joly.kevin25@gmail.com>
+
+2019-10-29 11:43:05 +0900  Seungha Yang <seungha.yang@navercorp.com>
+
+	* ext/libav/gstavviddec.c:
+	  avviddec: Fix huge leak caused by circular reference
+	  AVBufferRef -> GstFFMpegVideoDecVideoFrame -> GstVideoCodecFrame -> AVBufferRef
+	  Instead of holding additional ref there, set read-only which would not be
+	  reused by ff_reget_buffer()
+	  Fixes: https://gitlab.freedesktop.org/gstreamer/gst-libav/issues/63
+
+2019-10-25 01:09:08 +0900  Seungha Yang <seungha.yang@navercorp.com>
+
+	* ext/libav/gstavviddec.c:
+	* ext/libav/gstavvidenc.c:
+	  avvideenc,avvidedec: Filtering hardware en/decoder by flag
+	  ... instead of filtering them by hardcoded string compare.
+
+2019-10-24 00:25:28 +0900  Seungha Yang <seungha.yang@navercorp.com>
+
+	* ext/libav/gstavviddec.c:
+	  avviddec: Enforce allocate new AVFrame per input frame
+	  ... if ffmpeg would reuse the allocated AVBuffer. Reused AVFrame by
+	  the ffmpeg seems to break our decoding flow since the reused AVFrame
+	  holds the initial opaque data (GstVideoCodecFrame in this case), so
+	  we couldn't trace the our in/out frames.
+	  To enforce get_buffer() call per output frame, hold another reference
+	  to the AVBuffer in order to mark the AVBuffer as not writable.
+	  Fixes: https://gitlab.freedesktop.org/gstreamer/gst-libav/issues/62
+
+2019-10-13 14:33:27 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* .gitignore:
+	* .gitmodules:
+	* HACKING:
+	* Makefile.am:
+	* README:
+	* TODO:
+	* autogen.sh:
+	* common:
+	* configure.ac:
+	* docs/.gitignore:
+	* ext/Makefile.am:
+	* ext/libav/Makefile.am:
+	* gst-libs/Makefile.am:
+	* gst-libs/ext/Makefile.am:
+	* gst-libs/ext/gas-preprocessor:
+	* gst-libs/ext/libav:
+	* m4/as-slurp-ffmpeg.m4:
+	* pkgconfig/.gitignore:
+	* pkgconfig/Makefile.am:
+	* tests/Makefile.am:
+	* tests/check/.gitignore:
+	* tests/check/Makefile.am:
+	* tests/check/generic/.gitignore:
+	* tests/files/Makefile.am:
+	  Remove autotools build system
+
+2019-09-24 23:51:33 +0900  Seungha Yang <seungha.yang@navercorp.com>
+
+	* ext/libav/gstavcodecmap.c:
+	* ext/libav/gstavviddec.c:
+	  avviddec,avcodemap: Use new helper function for map color space information
+	  ... between GStreamer and FFmpeg. Note that FFmpeg follows ISO/IEC 23001-8
+	  defined color{matrix,transfer,primaries} values.
+
+2019-09-11 15:59:42 +0000  Marc Leeman <marc.leeman@gmail.com>
+
+	* docs/meson.build:
+	  docs: do not require gst-plugins-doc-cache-generator
+	  Do not require the cache generator. This is in line with the other
+	  gstreamer modules
+
+2019-08-13 22:03:31 +0200  Mathieu Duponchelle <mathieu@centricular.com>
+
+	* ext/libav/gstavvidenc.c:
+	  avvidenc: timestamp output buffers
+	  Same approach as x264enc, with the one hour offset
+
+2019-08-01 16:27:35 -0400  Doug Nazar <nazard@nazar.ca>
+
+	* ext/libav/gstavauddec.c:
+	  avauddec: Don't warn if drain is successful
+
+2019-07-18 00:20:16 +0200  Mathieu Duponchelle <mathieu@centricular.com>
+
+	* ext/libav/gstavviddec.c:
+	  avviddec: improve latency calculation
+	  When thread_type is set to FF_THREAD_FRAME, per the documentation
+	  a latency of one frame per thread is introduced:
+	  <https://ffmpeg.org/ffmpeg-codecs.html>, search for thread_type.
+	  Additionally, we need in that case to calculate the automatic
+	  number of threads ourselves, so as to accurately calculate the
+	  latency.
+
+2018-10-06 18:51:58 +0900  Seungha Yang <seungha.yang@navercorp.com>
+
+	* ext/libav/gstavviddec.c:
+	* ext/libav/gstavviddec.h:
+	  avviddec: Add thread-type property
+	  The thread-type property allows specifying preferred
+	  multithreading methods by user. Note that FF_THREAD_FRAME
+	  may introduce additional latency especially on non-filesrc usecase,
+	  since it introduces a decoding delay of (number of threads) frames.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=797254
+
+2019-07-15 10:42:42 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavvidenc.c:
+	  avvidenc: Close reference context before freeing it
+	  Otherwise we'll leak some memory.
+	  See https://gitlab.freedesktop.org/gstreamer/gst-libav/merge_requests/32
+
+2019-07-12 14:41:18 +0200  Knut Andre Tidemann <knutandre.tidemann@zenitel.com>
+
+	* ext/libav/gstavaudenc.c:
+	  avaudenc: fix memory leak of refcontext after finalize.
+
+2019-06-19 15:44:49 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavvidenc.c:
+	  avvidenc: Also set the repeat_pict flag correctly and take the TFF flag from caps if available
+
+2019-06-19 15:43:42 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/libav/gstavvidenc.c:
+	  avvidenc: Correctly signal interlaced input to ffmpeg when the input caps are interlaced
+	  Regression from 1e4529ced2dadbfed4ac10d639a45dbcb0660129
+
+2019-06-02 21:45:19 +0200  Niels De Graef <niels.degraef@barco.com>
+
+	* configure.ac:
+	  meson: Bump minimal GLib version to 2.44
+	  This means we can use some newer features and get rid of some
+	  boilerplate code using the G_DECLARE_* macros.
+	  As discussed on IRC, 2.44 is old enough by now to start depending on it.
+
+2019-05-29 11:49:38 +0530  Guillaume Desmottes <guillaume.desmottes@collabora.com>
+
+	* ext/libav/gstavviddec.c:
+	  avviddec: remove cdgraphics element
+	  It was never usable as we don't have a parser and we now have 'cdgdec'
+	  in gst-plugins-rs.
+
+2019-05-25 13:36:40 +0200  Tim-Philipp Müller <tim@centricular.com>
+
+	* configure.ac:
+	  configure: pass -Wno-attributes to fix build against broken ffmpeg headers
+	  libavutil/mem.h:342:1: error: ‘alloc_size’ attribute ignored on a function returning ‘int’
+	  av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
+	  ^~~~~~~~~~~~~
+	  Hopefully fixes build on jenkins.
+
+2019-05-24 20:35:41 +0900  Seungha Yang <seungha.yang@navercorp.com>
+
+	* ext/libav/gstavcodecmap.c:
+	* ext/libav/gstavviddec.c:
+	  avcodecmap,avviddec: Map bt2020-10, PQ and HLG transfer functions
+	  Map more transfer functions between Gstreamer and ffmpeg
+
+2019-05-24 11:47:58 +0200  Arun Raghavan <arun@arunraghavan.net>
+
+	* docs/gst_plugins_cache.json:
+	* ext/libav/gstavcodecmap.c:
+	  codecmap: Add caps for aptX and aptX-HD
+
+2019-05-16 09:20:56 -0400  Thibault Saunier <tsaunier@igalia.com>
+
+	* docs/gst_plugins_cache.json:
+	* docs/meson.build:
+	  docs: Stop building the doc cache by default
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gst-docs/issues/36
+
+2019-05-13 22:58:09 -0400  Thibault Saunier <tsaunier@igalia.com>
+
+	* docs/gst_plugins_cache.json:
+	  docs: Update plugins documentation cache
+
+2018-10-22 11:41:07 +0200  Thibault Saunier <tsaunier@igalia.com>
+
+	* Makefile.am:
+	* configure.ac:
+	* docs/Makefile.am:
+	* docs/gst_plugins_cache.json:
+	* docs/index.md:
+	* docs/meson.build:
+	* docs/plugins/.gitignore:
+	* docs/plugins/Makefile.am:
+	* docs/plugins/gst-libav-plugins-docs.sgml:
+	* docs/plugins/gst-libav-plugins.args:
+	* docs/plugins/gst-libav-plugins.hierarchy:
+	* docs/plugins/gst-libav-plugins.interfaces:
+	* docs/plugins/gst-libav-plugins.prerequisites:
+	* docs/plugins/gst-libav-plugins.signals:
+	* docs/plugins/gst-libav-plugins.types:
+	* docs/plugins/inspect/plugin-libav.xml:
+	* docs/plugins/scanobj-build.stamp:
+	* docs/sitemap.txt:
+	* docs/version.entities.in:
+	* ext/libav/meson.build:
+	* meson.build:
+	* meson_options.txt:
+	  docs: Port to hotdoc
+
+2019-05-05 09:38:01 +0200  Christoph Reiter <reiter.christoph@gmail.com>
+
+	* configure.ac:
+	  autotools: add bcrypt to win32 libs
+	  The included libav requires it now. Otherwise the builds fails with:
+	  CCLD     libgstlibav.la
+	  build-i686-w64-mingw32/gst-libs/ext/.libs/libavutil.a(random_seed.o): In function `av_get_random_seed':
+	  gst-libav-1.16.0/gst-libs/ext/libav/libavutil/random_seed.c:126: undefined reference to `BCryptOpenAlgorithmProvider@16'
+	  gst-libav-1.16.0/gst-libs/ext/libav/libavutil/random_seed.c:129: undefined reference to `BCryptGenRandom@16'
+	  gst-libav-1.16.0/gst-libs/ext/libav/libavutil/random_seed.c:130: undefined reference to `BCryptCloseAlgorithmProvider@8'
+	  collect2.exe: error: ld returned 1 exit status
+
+2019-02-18 20:53:58 +0900  Seungha Yang <seungha.yang@navercorp.com>
+
+	* ext/libav/gstavviddec.c:
+	  avviddec: Extract HDR information if any
+	  Convert mastering display information (a.k.a HDR static metadata) and
+	  content light level information provided by FFMPEG to Gstreamer.
+
+2019-04-29 11:52:31 +0900  Yeongjin Jeong <yeongjin.jeong@navercorp.com>
+
+	* ext/libav/gstav.c:
+	  gstav: Use libavcodec util function for version check
+	  The version of libavutil is printed in the log instead of libavcodec
+	  because avutil_version() returns LIBAVUTIL_VERSION_INT. This can be confusing,
+	  so we should be replace it with avcodec_version().
+
+2019-04-29 15:22:52 +0900  Yeongjin Jeong <yeongjin.jeong@navercorp.com>
+
+	* ext/libav/gstavauddec.c:
+	  avauddec: Ensure drain even if codec has not delay capabilities
+	  There are decoders that need to be drained if they work on multi-threads,
+	  even if AV_CODEC_CAP_DELAY is not set.
+
+2019-04-29 15:02:06 +0900  Yeongjin Jeong <yeongjin.jeong@navercorp.com>
+
+	* ext/libav/gstavviddec.c:
+	  avviddec: Ensure drain even if codec has not delay capabilities
+	  There are decoders that need to be drained if they work on multi-threads,
+	  even if AV_CODEC_CAP_DELAY is not set.
+
+2019-04-19 10:38:06 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* RELEASE:
+	* configure.ac:
+	* docs/plugins/inspect/plugin-libav.xml:
+	* meson.build:
+	  Back to development
+
 === release 1.16.0 ===
 
 2019-04-19 00:33:22 +0100  Tim-Philipp Müller <tim@centricular.com>
@@ -11792,11 +12241,11 @@
 	  Original commit message from CVS:
 	  ChangeLog surgery: UTF8-ize latest entry
 
-2007-11-08 14:44:36 +0000  Ole Andr� Vadla Ravn�s <ole.andre.ravnas@tandberg.com>
+2007-11-08 14:44:36 +0000  Ole Andr� Vadla Ravn�s <ole.andre.ravnas@tandberg.com>
 
 	  ext/ffmpeg/:
 	  Original commit message from CVS:
-	  Patch by: Ole Andr� Vadla Ravn�s <ole dot andre dot ravnas at tandberg dot com>
+	  Patch by: Ole Andr� Vadla Ravn�s <ole dot andre dot ravnas at tandberg dot com>
 	  * ext/ffmpeg/gstffmpegcodecmap.c: (gst_ffmpeg_caps_with_codecid):
 	  * ext/ffmpeg/gstffmpegmux.c: (gst_ffmpegmux_init):
 
diff --git a/NEWS b/NEWS
index 816a3aa..a4e7232 100644
--- a/NEWS
+++ b/NEWS
@@ -1,14 +1,30 @@
 
 
-GSTREAMER 1.16 RELEASE NOTES
+GSTREAMER 1.18 RELEASE NOTES
 
 
-GStreamer 1.16.0 was originally released on 19 April 2019.
+THESE RELEASE NOTES ARE A PLACEHOLDER, PLEASE BEAR WITH US WHILE WE
+FINISH WRITING UP THE REAL THING.
 
-See https://gstreamer.freedesktop.org/releases/1.16/ for the latest
+GStreamer 1.18.0 has not yet been released. It is scheduled for release
+in summer 2020 now.
+
+1.17.x is the unstable development series that is currently being
+developed in the git master branch and which will eventually result in
+1.18, and 1.17.1 is the current development release in that series.
+
+The schedule for the 1.18 development cycle is yet to be confirmed, but
+it is expected that feature freeze will be in June/July 2020, followed
+by several 1.17 pre-releases and then a new 1.18 stable release in
+July/August 2020.
+
+1.18 will be backwards-compatible to the stable 1.16, 1.14, 1.12, 1.10,
+1.8, 1.6, 1.4, 1.2 and 1.0 release series.
+
+See https://gstreamer.freedesktop.org/releases/1.18/ for the latest
 version of this document.
 
-_Last updated: Friday 19 April 2019, 00:00 UTC (log)_
+_Last updated: Thursday 18 June 2020, 16:00 UTC (log)_
 
 
 Introduction
@@ -23,1146 +39,133 @@ fixes and other improvements.
 
 Highlights
 
--   GStreamer WebRTC stack gained support for data channels for
-    peer-to-peer communication based on SCTP, BUNDLE support, as well as
-    support for multiple TURN servers.
-
--   AV1 video codec support for Matroska and QuickTime/MP4 containers
-    and more configuration options and supported input formats for the
-    AOMedia AV1 encoder
-
--   Support for Closed Captions and other Ancillary Data in video
-
--   Support for planar (non-interleaved) raw audio
-
--   GstVideoAggregator, compositor and OpenGL mixer elements are now in
-    -base
-
--   New alternate fields interlace mode where each buffer carries a
-    single field
-
--   WebM and Matroska ContentEncryption support in the Matroska demuxer
-
--   new WebKit WPE-based web browser source element
-
--   Video4Linux: HEVC encoding and decoding, JPEG encoding, and improved
-    dmabuf import/export
-
--   Hardware-accelerated Nvidia video decoder gained support for VP8/VP9
-    decoding, whilst the encoder gained support for H.265/HEVC encoding.
-
--   Many improvements to the Intel Media SDK based hardware-accelerated
-    video decoder and encoder plugin (msdk): dmabuf import/export for
-    zero-copy integration with other components; VP9 decoding; 10-bit
-    HEVC encoding; video post-processing (vpp) support including
-    deinterlacing; and the video decoder now handles dynamic resolution
-    changes.
-
--   The ASS/SSA subtitle overlay renderer can now handle multiple
-    subtitles that overlap in time and will show them on screen
-    simultaneously
-
--   The Meson build is now feature-complete (*) and it is now the
-    recommended build system on all platforms. The Autotools build is
-    scheduled to be removed in the next cycle.
-
--   The GStreamer Rust bindings and Rust plugins module are now
-    officially part of upstream GStreamer.
-
--   The GStreamer Editing Services gained a gesdemux element that allows
-    directly playing back serialized edit list with playbin or
-    (uri)decodebin
-
--   Many performance improvements
+-   FIXME
 
 
 Major new features and changes
 
 Noteworthy new API
 
--   GstAggregator has a new "min-upstream-latency" property that forces
-    a minimum aggregate latency for the input branches of an aggregator.
-    This is useful for dynamic pipelines where branches with a higher
-    latency might be added later after the pipeline is already up and
-    running and where a change in the latency would be disruptive. This
-    only applies to the case where at least one of the input branches is
-    live though, it won’t force the aggregator into live mode in the
-    absence of any live inputs.
-
--   GstBaseSink gained a "processing-deadline" property and
-    setter/getter API to configure a processing deadline for live
-    pipelines. The processing deadline is the acceptable amount of time
-    to process the media in a live pipeline before it reaches the sink.
-    This is on top of the systemic latency that is normally reported by
-    the latency query. This defaults to 20ms and should make pipelines
-    such as v4l2src ! xvimagesink not claim that all frames are late in
-    the QoS events. Ideally, this should replace the "max-lateness"
-    property for most applications.
-
--   RTCP Extended Reports (XR) parsing according to RFC 3611:
-    Loss/Duplicate RLE, Packet Receipt Times, Receiver Reference Time,
-    Delay since the last Receiver (DLRR), Statistics Summary, and VoIP
-    Metrics reports. This only provides the ability to parse such
-    packets, generation of XR packets is not supported yet and XR
-    packets are not automatically parsed by rtpbin / rtpsession but must
-    be actively handled by the application.
-
--   a new mode for interlaced video was added where each buffer carries
-    a single field of interlaced video, with buffer flags indicating
-    whether the field is the top field or bottom field. Top and bottom
-    fields are expected to alternate in this mode. Caps for this
-    interlace mode must also carry a format:Interlaced caps feature to
-    ensure backwards compatibility.
-
--   The video library has gained support for three new raw pixel
-    formats:
-
-    -   Y410: packed 4:4:4 YUV, 10 bits per channel
-    -   Y210: packed 4:2:2 YUV, 10 bits per channel
-    -   NV12_10LE40: fully-packed 10-bit variant of NV12_10LE32,
-        i.e. without the padding bits
-
--   GstRTPSourceMeta is a new meta that can be used to transport
-    information about the origin of depayloaded or decoded RTP buffers,
-    e.g. when mixing audio from multiple sources into a single stream. A
-    new "source-info" property on the RTP depayloader base class
-    determines whether depayloaders should put this meta on outgoing
-    buffers. Similarly, the same property on RTP payloaders determines
-    whether they should use the information from this meta to construct
-    the CSRCs list on outgoing RTP buffers.
-
--   gst_sdp_message_from_text() is a convenience constructor to parse
-    SDPs from a string which is particularly useful for language
-    bindings.
-
-Support for Planar (Non-Interleaved) Raw Audio
-
-Raw audio samples are usually passed around in interleaved form in
-GStreamer, which means that if there are multiple audio channels the
-samples for each channel are interleaved in memory, e.g.
-|LEFT|RIGHT|LEFT|RIGHT|LEFT|RIGHT| for stereo audio. A non-interleaved
-or planar arrangement in memory would look like
-|LEFT|LEFT|LEFT|RIGHT|RIGHT|RIGHT| instead, possibly with
-|LEFT|LEFT|LEFT| and |RIGHT|RIGHT|RIGHT| residing in separate memory
-chunks or separated by some padding.
-
-GStreamer has always had signalling for non-interleaved audio since
-version 1.0, but it was never actually properly implemented in any
-elements. audioconvert would advertise support for it, but wasn’t
-actually able to handle it correctly.
-
-With this release we now have full support for non-interleaved audio as
-well, which means more efficient integration with external APIs that
-handle audio this way, but also more efficient processing of certain
-operations like interleaving multiple 1-channel streams into a
-multi-channel stream which can be done without memory copies now.
-
-New API to support this has been added to the GStreamer Audio support
-library: There is now a new GstAudioMeta which describes how data is
-laid out inside the buffer, and buffers with non-interleaved audio must
-always carry this meta. To access the non-interleaved audio samples you
-must map such buffers with gst_audio_buffer_map() which works much like
-gst_buffer_map() or gst_video_frame_map() in that it will populate a
-little GstAudioBuffer helper structure passed to it with the number of
-samples, the number of planes and pointers to the start of each plane in
-memory. This function can also be used to map interleaved audio buffers
-in which case there will be only one plane of interleaved samples.
-
-Of course support for this has also been implemented in the various
-audio helper and conversion APIs, base classes, and in elements such as
-audioconvert, audioresample, audiotestsrc, audiorate.
-
-Support for Closed Captions and Other Ancillary Data in Video
-
-The video support library has gained support for detecting and
-extracting Ancillary Data from videos as per the SMPTE S291M
-specification, including:
-
--   a VBI (Vertical Blanking Interval) parser that can detect and
-    extract Ancillary Data from Vertical Blanking Interval lines of
-    component signals. This is currently supported for videos in v210
-    and UYVY format.
-
--   a new GstMeta for closed captions: GstVideoCaptionMeta. This
-    supports the two types of closed captions, CEA-608 and CEA-708,
-    along with the four different ways they can be transported (other
-    systems are a superset of those).
-
--   a VBI (Vertical Blanking Interval) encoder for writing ancillary
-    data to the Vertical Blanking Interval lines of component signals.
-
-The new closedcaption plugin in gst-plugins-bad then makes use of all
-this new infrastructure and provides the following elements:
-
--   cccombiner: a closed caption combiner that takes a closed captions
-    stream and another stream and adds the closed captions as
-    GstVideoCaptionMeta to the buffers of the other stream.
-
--   ccextractor: a closed caption extractor which will take
-    GstVideoCaptionMeta from input buffers and output them as a separate
-    closed captions stream.
-
--   ccconverter: a closed caption converter that can convert between
-    different formats
-
--   line21encoder, line21decoder: inject/extract line21 closed captions
-    to/from SD video streams
-
--   cc708overlay: decodes CEA 608/708 captions and overlays them on
-    video
-
-Additionally, the following elements have also gained Closed Caption
-support:
-
--   qtdemux and qtmux support CEA 608/708 Closed Caption tracks
-
--   mpegvideoparse, h264parse extracts Closed Captions from MPEG-2/H.264
-    video streams
-
--   avviddec, avvidenc, x264enc got support for extracting/injecting
-    Closed Captions
-
--   decklinkvideosink can output closed captions and decklinkvideosrc
-    can extract closed captions
-
--   playbin and playbin3 learned how to autoplug CEA 608/708 CC overlay
-    elements
-
--   the externally maintained ajavideosrc element for AJA capture cards
-    has support for extracting closed captions
-
-The rsclosedcaption plugin in the Rust plugins collection includes a
-MacCaption (MCC) file parser and encoder.
+-   FIXME
 
 New Elements
 
--   overlaycomposition: New element that allows applications to draw
-    GstVideoOverlayCompositions on a stream. The element will emit the
-    "draw" signal for each video buffer, and the application then
-    generates an overlay for that frame (or not). This is much more
-    performant than e.g. cairooverlay for many use cases, e.g. because
-    pixel format conversions can be avoided or the blitting of the
-    overlay can be delegated to downstream elements (such as
-    gloverlaycompositor). It’s particularly useful for cases where only
-    a small section of the video frame should be drawn on.
-
--   gloverlaycompositor: New OpenGL-based compositor element that
-    flattens any overlays from GstVideoOverlayCompositionMetas into the
-    video stream. This element is also always part of glimagesink.
-
--   glalpha: New element that adds an alpha channel to a video stream.
-    The values of the alpha channel can either be set to a constant or
-    can be dynamically calculated via chroma keying. It is similar to
-    the existing alpha element but based on OpenGL. Calculations are
-    done in floating point so results may not be identical to the output
-    of the existing alpha element.
-
--   rtpfunnel funnels together RTP streams into a single session. Use
-    cases include multiplexing and bundle. webrtcbin uses it to
-    implement BUNDLE support.
-
--   testsrcbin is a source element that provides an audio and/or video
-    stream and also announces them using the recently-introduced
-    GstStream API. This is useful for testing elements such as playbin3
-    or uridecodebin3 etc.
-
--   New closed caption elements: cccombiner, ccextractor, ccconverter,
-    line21encoder, line21decoder and cc708overlay (see above)
-
--   wpesrc: new source element acting as a Web Browser based on WebKit
-    WPE
-
--   Two new OpenCV-based elements: cameracalibrate and cameraundistort
-    that can communicate to figure out distortion correction parameters
-    for a camera and correct for the distortion.
-
--   New sctp plugin based on usrsctp with sctpenc and sctpdec elements.
-    These elements are used inside webrtcbin for implementing data
-    channels.
+-   FIXME
 
 New element features and additions
 
--   playbin3, playbin and playsink have gained a new "text-offset"
-    property to adjust the positioning of the selected subtitle stream
-    vis-a-vis the audio and video streams. This uses subtitleoverlay’s
-    new "subtitle-ts-offset" property. GstPlayer has gained matching API
-    for this, namely gst_player_get_text_video_offset().
-
--   playbin3 buffering improvements: in network playback scenarios there
-    may be multiple inputs to decodebin3, and buffering will be done
-    before decodebin3 using queue2 or downloadbuffer elements inside
-    urisourcebin. Since this is before any parsers or demuxers there may
-    not be any bitrate information available for the various streams, so
-    it was difficult to configure the buffering there smartly within
-    global constraints. This was improved now: The queue2 elements
-    inside urisourcebin will now use the new bitrate query to figure out
-    a bitrate estimate for the stream if no bitrate was provided by
-    upstream, and urisourcebin will use the bitrates of the individual
-    queues to distribute the globally-set "buffer-size" budget in bytes
-    to the various queues. urisourcebin also gained "low-watermark" and
-    "high-watermark" properties which will be proxied to the internal
-    queues, as well as a read-only "statistics" property which allows
-    querying of the minimum/maximum/average byte and time levels of the
-    queues inside the urisourcebin in question.
-
--   splitmuxsink has gained a couple of new features:
-
-    -   new "async-finalize" mode: This mode is useful for muxers or
-        outputs that can take a long time to finalize a file. Instead of
-        blocking the whole upstream pipeline while the muxer is doing
-        its stuff, we can unlink it and spawn a new muxer + sink
-        combination to continue running normally. This requires us to
-        receive the muxer and sink (if needed) as factories via the new
-        "muxer-factory" and "sink-factory" properties, optionally
-        accompanied by their respective properties structures (set via
-        the new "muxer-properties" and "sink-properties" properties).
-        There are also new "muxer-added" and "sink-added" signals in
-        case custom code has to be called for them to configure them.
-
-    -   "split-at-running-time" action signal: When called by the user,
-        this action signal ends the current file (and starts a new one)
-        as soon as the given running time is reached. If called multiple
-        times, running times are queued up and processed in the order
-        they were given.
-
-    -   "split-after" action signal to finish outputting the current GOP
-        to the current file and then start a new file as soon as the GOP
-        is finished and a new GOP is opened (unlike the existing
-        "split-now" which immediately finishes the current file and
-        writes the current GOP into the next newly-started file).
-
-    -   "reset-muxer" property: when unset, the muxer is reset using
-        flush events instead of setting its state to NULL and back. This
-        means the muxer can keep state across resets, e.g. mpegtsmux
-        will keep the continuity counter continuous across segments as
-        required by hlssink2.
-
--   qtdemux gained PIFF track encryption box support in addition to the
-    already-existing PIFF sample encryption support, and also allows
-    applications to select which encryption system to use via a
-    "drm-preferred-decryption-system-id" context in case there are
-    multiple options.
-
--   qtmux: the "start-gap-threshold" property determines now whether an
-    edit list will be created to account for small gaps or offsets at
-    the beginning of a stream in case the start timestamps of tracks
-    don’t line up perfectly. Previously the threshold was hard-coded to
-    1% of the (video) frame duration, now it is 0 by default (so edit
-    list will be created even for small differences), but fully
-    configurable.
-
--   rtpjitterbuffer has improved end-of-stream handling
-
--   rtpmp4vpay will be prefered over rtpmp4gpay for MPEG-4 video in
-    autoplugging scenarios now
-
--   rtspsrc now allows applications to send RTSP SET_PARAMETER and
-    GET_PARAMETER requests using action signals.
-
--   rtspsrc has a small (100ms) configurable teardown delay by default
-    to try and make sure an RTSP TEARDOWN request gets sent out when the
-    source element shuts down. This will block the downward PAUSED to
-    READY state change for a short time, but can be disabled where it’s
-    a problem. Some servers only allow a limited number of concurrent
-    clients, so if no proper TEARDOWN is sent new clients may have
-    problems connecting to the server for a while.
-
--   souphttpsrc behaves better with low bitrate streams now. Before it
-    would increase the read block size too quickly which could lead to
-    it not reading any data from the socket for a very long time with
-    low bitrate streams that are output live downstream. This could lead
-    to servers kicking off the client.
-
--   filesink: do internal buffering to avoid performance regression with
-    small writes since we bypass libc buffering by using writev()
-    instead of fwrite()
-
--   identity: add "eos-after" property and fix "error-after" property
-    when the element is reused
-
--   input-selector: lets context queries pass through, so that
-    e.g. upstream OpenGL elements can use contexts and displays
-    advertised by downstream elements
-
--   queue2: avoid ping-pong between 0% and 100% buffering messages if
-    upstream is pushing buffers larger than one of its limits, plus
-    performance optimisations
-
--   opusdec: new "phase-inversion" property to control phase inversion.
-    When enabled, this will slightly increase stereo quality, but
-    produces a stream that when downmixed to mono will suffer audio
-    distortions.
-
--   The x265enc HEVC encoder also exposes a "key-int-max" property to
-    configure the maximum allowed GOP size now.
-
--   decklinkvideosink has seen stability improvements for long-running
-    pipelines (potential crash due to overflow of leaked clock refcount)
-    and clock-slaving improvements when performing flushing seeks
-    (causing stalls in the output timeline), pausing and/or buffering.
-
--   srtpdec, srtpenc: add support for MKIs which allow multiple keys to
-    be used with a single SRTP stream
-
--   srtpdec, srtpenc: add support for AES-GCM and also add support for
-    it in gst-rtsp-server and rtspsrc.
-
--   The srt Secure Reliable Transport plugin has integrated server and
-    client elements srt{client,server}{src,sink} into one (srtsrc and
-    srtsink), since SRT connection mode can be changed by uri
-    parameters.
-
--   h264parse and h265parse will handle SEI recovery point messages and
-    mark recovery points as keyframes as well (in addition to IDR
-    frames)
-
--   webrtcbin: "add-turn-server" action signal to pass multiple ICE
-    relays (TURN servers).
-
--   The removesilence element has received various new features and
-    properties, such as a "threshold" property, detecting silence only
-    after minimum silence time/buffers, a "silent" property to control
-    bus message notifications as well as a "squash" property.
-
--   AOMedia AV1 decoder gained support for 10/12bit decoding whilst the
-    AV1 encoder supports more image formats and subsamplings now and
-    acquired support for rate control and profile related configuration.
-
--   The Fraunhofer fdkaac plugin can now be built against the 2.0.0
-    version API and has improved multichannel support
-
--   kmssink now supports unpadded 24-bit RGB and can configure mode
-    setting from video info, which enables display of multi-planar
-    formats such as I420 or NV12 with modesetting. It has also gained a
-    number of new properties: The "restore-crtc" property does what it
-    says on the tin and is enabled by default. "plane-properties" and
-    "connector-properties" can be used to pass custom properties to the
-    DRM.
-
--   waylandsink has a "fullscreen" property now and supports the
-    XDG-Shell protocol.
-
--   decklinkvideosink, decklinkvideosrc support selecting between
-    half/full duplex
-
--   The vulkan plugin gained support for macOS and iOS via MoltenVK in
-    addition to the existing support for X11 and Wayland
-
--   imagefreeze has a new num-buffers property to limit the number of
-    buffers that are produced and to send an EOS event afterwards
-
--   webrtcbin has a new, introspectable get-transceiver signal in
-    addition to the old get-transceivers signal that couldn’t be used
-    from bindings
-
--   Support for per-element latency information was added to the latency
-    tracer
+-   FIXME
 
 Plugin and library moves
 
--   The stereo element was moved from -bad into the existing audiofx
-    plugin in -good. If you get duplicate type registration warnings
-    when upgrading, check that you don’t have a stale stereoplugin lying
-    about somewhere.
-
-GstVideoAggregator, compositor, and OpenGL mixer elements moved from -bad to -base
-
-GstVideoAggregator is a new base class for raw video mixers and muxers
-and is based on GstAggregator. It provides defined-latency mixing of raw
-video inputs and ensures that the pipeline won’t stall even if one of
-the input streams stops producing data.
-
-As part of the move to stabilise the API there were some last-minute API
-changes and clean-ups, but those should mostly affect internal elements.
-Most notably, the "ignore-eos" pad property was renamed to
-"repeat-after-eos" and the conversion code was moved to a
-GstVideoAggregatorConvertPad subclass to avoid code duplication, make
-things less awkward for subclasses like the OpenGL-based video mixer,
-and make the API more consistent with the audio aggregator API.
-
-It is used by the compositor element, which is a replacement for
-‘videomixer’ which did not handle live inputs very well. compositor
-should behave much better in that respect and generally behave as one
-would expected in most scenarios.
-
-The compositor element has gained support for per-pad blending mode
-operators (SOURCE, OVER, ADD) which determines what operator to use for
-blending this pad over the previous ones. This can be used to implement
-crossfading and the available operators can be extended in the future as
-needed.
-
-A number of OpenGL-based video mixer elements (glvideomixer, glmixerbin,
-glvideomixerelement, glstereomix, glmosaic) which are built on top of
-GstVideoAggregator have also been moved from -bad to -base now. These
-elements have been merged into the existing OpenGL plugin, so if you get
-duplicate type registration warnings when upgrading, check that you
-don’t have a stale openglmixers plugin lying about somewhere.
+-   FIXME
 
 Plugin removals
 
 The following plugins have been removed from gst-plugins-bad:
 
--   The experimental daala plugin has been removed, since it’s not so
-    useful now that all effort is focused on AV1 instead, and it had to
-    be enabled explicitly with --enable-experimental anyway.
-
--   The spc plugin has been removed. It has been replaced by the gme
-    plugin.
-
--   The acmmp3dec and acmenc plugins for Windows have been removed. ACM
-    is an ancient legacy API and there was no point in keeping the
-    plugins around for a licensed MP3 decoder now that the MP3 patents
-    have expired and we have a decoder in -good. We also didn’t ship
-    these in our cerbero-built Windows packages, so it’s unlikely that
-    they’ll be missed.
+-   FIXME
 
 
 Miscellaneous API additions
 
--   GstBitwriter: new generic bit writer API to complement the existing
-    bit reader
-
--   gst_buffer_new_wrapped_bytes() creates a wrap buffer from a GBytes
-
--   gst_caps_set_features_simple() sets a caps feature on all the
-    structures of a GstCaps
-
--   New GST_QUERY_BITRATE query: This allows determining from downstream
-    what the expected bitrate of a stream may be which is useful in
-    queue2 for setting time based limits when upstream does not provide
-    timing information. tsdemux, qtdemux and matroskademux have basic
-    support for this query on their sink pads.
-
--   elements: there is a new “Hardware” class specifier. Elements
-    interacting with hardware devices should specify this classifier in
-    their element factory class metadata. This is useful to advertise as
-    one might need to put such elements into READY state to test if the
-    hardware is present in the system for example.
-
--   protection: Add a new definition for unspecified system protection,
-    GST_PROTECTION_UNSPECIFIED_SYSTEM_ID
-
--   take functions for various mini objects that didn’t have them yet:
-    gst_query_take(), gst_message_take(), gst_tag_list_take(),
-    gst_buffer_list_take(). Unlike the various _replace() functions
-    _take() does not increase the reference count but takes ownership of
-    the mini object passed.
-
--   clear functions for various mini object types and GstObject which
-    unrefs the object or mini object (if non-NULL) and sets the variable
-    pointed to to NULL: gst_clear_structure(), gst_clear_tag_list(),
-    gst_clear_query(), gst_clear_message(), gst_clear_event(),
-    gst_clear_caps(), gst_clear_buffer_list(), gst_clear_buffer(),
-    gst_clear_mini_object(), gst_clear_object()
-
--   miniobject: new API gst_mini_object_add_parent() and
-    gst_mini_object_remove_parent() to set parent pointers on mini
-    objects to ensure correct writability: Every container of
-    miniobjects now needs to store itself as parent in the child object,
-    and remove itself again later. A mini object is then only writable
-    if there is at most one parent, that parent is writable itself, and
-    the reference count of the mini object is 1. GstBuffer (for
-    memories), GstBufferList (for buffers), GstSample (for caps, buffer,
-    bufferlist), and GstVideoOverlayComposition were updated
-    accordingly. Without this it was possible to have e.g. a buffer list
-    with a refcount of 2 used in two places at once that both modify the
-    same buffer with refcount 1 at the same time wrongly thinking it is
-    writable even though it’s really not.
-
--   poll: add API to watch for POLLPRI and stop treating POLLPRI as a
-    read. This is useful to wait for video4linux events which are
-    signalled via POLLPRI.
-
--   sample: new API to update the contents of a GstSample and make it
-    writable: gst_sample_set_buffer(), gst_sample_set_caps(),
-    gst_sample_set_segment(), gst_sample_set_info(), plus
-    gst_sample_is_writable() and gst_sample_make_writable(). This makes
-    it possible to reuse a sample object and avoid unnecessary memory
-    allocations, for example in appsink.
-
--   ClockIDs now keep a weak reference to underlying clock to avoid
-    crashes in basesink in corner cases where a clock goes away while
-    the ClockID is still in use, plus some new API
-    (gst_clock_id_get_clock(), gst_clock_id_uses_clock()) to check the
-    clock a ClockID is linked to.
-
--   The GstCheck unit test library gained a
-    fail_unless_equals_clocktime() convenience macro as well as some new
-    GstHarness API for for proposing meta APIs from the allocation
-    query: gst_harness_add_propose_allocation_meta(). ASSERT_CRITICAL()
-    checks in unit tests are now skipped if GStreamer was compiled with
-    GST_DISABLE_GLIB_CHECKS.
-
--   gst_audio_buffer_truncate() convenience function to truncate a raw
-    audio buffer
-
--   GstDiscoverer has support for caching the results of discovery in
-    the default cache directory. This can be enabled with the use-cache
-    property and is disabled by default.
-
--   GstMeta that are attached to GstBuffers are now always stored in the
-    order in which they were added.
-
--   Additional support for signalling ONVIF specific features were
-    added: the SEEK event can store a trickmode-interval now and support
-    for the Rate-Control and Frames RTSP headers was added to the RTSP
-    library.
+-   FIXME
 
 
 Miscellaneous performance and memory optimisations
 
 As always there have been many performance and memory usage improvements
-across all components and modules. Some of them (such as dmabuf
-import/export) have already been mentioned elsewhere so won’t be
-repeated here.
+across all components and modules. Some of them have already been
+mentioned elsewhere so won’t be repeated here.
 
 The following list is only a small snapshot of some of the more
 interesting optimisations that haven’t been mentioned in other contexts
 yet:
 
--   The GstVideoEncoder and GstVideoDecoder base classes now release the
-    STREAM_LOCK when pushing out buffers, which means (multi-threaded)
-    encoders and decoders can now receive and continue to process input
-    buffers whilst waiting for downstream elements in the pipeline to
-    process the buffer that was pushed out. This increases throughput
-    and reduces processing latency, also and especially for
-    hardware-accelerated encoder/decoder elements.
-
--   GstQueueArray has seen a few API additions
-    (gst_queue_array_peek_nth(), gst_queue_array_set_clear_func(),
-    gst_queue_array_clear()) so that it can be used in other places like
-    GstAdapter instead of a GList, which reduces allocations and
-    improves performance.
-
--   appsink now reuses the sample object in pull_sample() if possible
-
--   rtpsession only starts the RTCP thread when it’s actually needed now
-
--   udpsrc uses a buffer pool now and the GstUdpSrc object structure was
-    optimised for better cache performance
+-   FIXME
 
 GstPlayer
 
--   API was added to fine-tune the synchronisation offset between
-    subtitles and video
+-   FIXME
 
 
 Miscellaneous changes
 
--   As a result of moving to newer FFmpeg APIs, encoder and decoder
-    elements exposed by the GStreamer FFmpeg wrapper plugin (gst-libav)
-    may have seen possibly incompatible changes to property names and/or
-    types, and not all properties exposed might be functional. We are
-    still reviewing the new properties and aim to minimise breaking
-    changes at least for the most commonly-used properties, so please
-    report any issues you run into!
+-   FIXME
 
 OpenGL integration
 
--   The OpenGL mixer elements have been moved from -bad to
-    gst-plugins-base (see above)
-
--   The Mesa GBM backend now supports headless mode
-
--   gloverlaycompositor: New OpenGL-based compositor element that
-    flattens any overlays from GstVideoOverlayCompositionMetas into the
-    video stream.
-
--   glalpha: New element that adds an alpha channel to a video stream.
-    The values of the alpha channel can either be set to a constant or
-    can be dynamically calculated via chroma keying. It is similar to
-    the existing alpha element but based on OpenGL. Calculations are
-    done in floating point so results may not be identical to the output
-    of the existing alpha element.
-
--   glupload: Implement direct dmabuf uploader, the idea being that some
-    GPUs (like the Vivante series) can actually perform the YUV->RGB
-    conversion internally, so no custom conversion shaders are needed.
-    To make use of this feature, we need an additional uploader that can
-    import DMABUF FDs and also directly pass the pixel format, relying
-    on the GPU to do the conversion.
-
--   The OpenGL library no longer restores the OpenGL viewport. This is a
-    performance optimization to not require performing multiple
-    expensive glGet*() function calls per frame. This affects any
-    application or plugin use of the following functions and objects:
-    -   glcolorconvert library object (not the element)
-    -   glviewconvert library object (not the element)
-    -   gst_gl_framebuffer_draw_to_texture()
-    -   custom GstGLWindow implementations
+-   FIXME
 
 
 Tracing framework and debugging improvements
 
--   There is now a GDB PRETTY PRINTER FOR VARIOUS GSTREAMER TYPES: For
-    GstObject pointers the type and name is added, e.g.
-    0x5555557e4110 [GstDecodeBin|decodebin0]. For GstMiniObject pointers
-    the object type is added, e.g. 0x7fffe001fc50 [GstBuffer]. For
-    GstClockTime and GstClockTimeDiff the time is also printed in human
-    readable form, e.g. 150116219955 [+0:02:30.116219955].
-
--   GDB EXTENSION WITH TWO CUSTOM GDB COMMANDS gst-dot AND gst-print:
-
-    -   gst-dot creates dot files that a very close to what
-        GST_DEBUG_BIN_TO_DOT_FILE() produces, but object properties and
-        buffer contents such as codec-data in caps are not available.
-
-    -   gst-print produces high-level information about a GStreamer
-        object. This is currently limited to pads for GstElements and
-        events for the pads. The output may look like this:
-
--   gst_structure_to_string() now serialises the actual value of
-    pointers when serialising GstStructures instead of claiming they’re
-    NULL. This makes debug logging in various places less confusing,
-    because it’s clear now that structure fields actually hold valid
-    objects. Such object pointer values will never be deserialised
-    however.
+-   FIXME
 
 
 Tools
 
--   gst-inspect-1.0 has coloured output now and will automatically use a
-    pager if the output does not fit on a page. This only works in a
-    UNIX environment and if the output is not piped, and on Windows 10
-    build 16257 or newer. If you don’t like the colours you can disable
-    them by setting the GST_INSPECT_NO_COLORS=1 environment variable or
-    passing the --no-color command line option.
+-   FIXME
 
 
 GStreamer RTSP server
 
--   Improved backlog handling when using TCP interleaved for data
-    transport. Before there was a fixed maximum size for backlog
-    messages, which was prone to deadlocks and made it difficult to
-    control memory usage with the watch backlog. The RTSP server now
-    limits queued TCP data messages to one per stream, moving queuing of
-    the data into the pipeline and leaving the RTSP connection
-    responsive to RTSP messages in both directions, preventing all those
-    problems.
-
--   Initial ULP Forward Error Correction support in rtspclientsink and
-    for RECORD mode in the server.
-
--   API to explicitly enable retransmission requests (RTX)
-
--   Lots of multicast-related fixes
-
--   rtsp-auth: Add support for parsing .htdigest files
+-   FIXME
 
 
 GStreamer VAAPI
 
--   Support Wayland’s display for context sharing, so the application
-    can pass its own wl_display in order to be used for the VAAPI
-    display creation.
-
--   A lot of work to support new Intel hardware using media-driver as VA
-    backend.
-
--   For non-x86 devices, VAAPI display can instantiate, through DRM,
-    with no PCI bus. This enables the usage of libva-v4l2-request
-    driver.
-
--   Added support for XDG-shell protocol as wl_shell replacement which
-    is currently deprecated. This change add as dependency
-    wayland-protocol.
-
--   GstVaapiFilter, GstVaapiWindow, and GstVaapiDecoder classes now
-    inherit from GstObject, gaining all the GStreamer’s instrumentation
-    support.
-
--   The metadata now specifies the plugin as Hardware class.
-
--   H264 decoder is more stable with problematic streams.
-
--   In H265 decoder added support for profiles main-422-10 (P010_10LE),
-    main-444 (AYUV) and main-444-10 (Y410)
-
--   JPEG decoder handles dynamic resolution changes.
-
--   More specification adherence in H264 and H265 encoders.
+-   FIXME
 
 
 GStreamer OMX
 
--   Add support of NV16 format to video encoders input.
-
--   Video decoders now handle the ALLOCATION query to tell upstream
-    about the number of buffers they require. Video encoders will also
-    use this query to adjust their number of allocated buffers
-    preventing starvation when using dynamic buffer mode.
-
--   The OMX_PERFORMANCE debug category has been renamed to OMX_API_TRACE
-    and can now be used to track a widder variety of interactions
-    between OMX and GStreamer.
-
--   Video encoders will now detect frame rate only changes and will
-    inform OMX about it rather than doing a full format reset.
-
--   Various Zynq UltraScale+ specific improvements:
-    -   Video encoders are now able to import dmabuf from upstream.
-    -   Support for HEVC range extension profiles and more AVC profiles.
-    -   We can now request video encoders to generate an IDR using the
-        force key unit event.
+-   FIXME
 
 
 GStreamer Editing Services and NLE
 
--   Added a gesdemux element, it is an auto pluggable element that
-    allows decoding edit list like files supported by GES
-
--   Added gessrc which wraps a GESTimeline as a standard source element
-    (implementing the ges protocol handler)
-
--   Added basic support for videorate::rate property potentially
-    allowing changing playback speed
-
--   Layer priority is now fully automatic and they should be moved with
-    the new ges_timeline_move_layer method, ges_layer_set_priority is
-    now deprecated.
-
--   Added a ges_timeline_element_get_layer_priority so we can simply get
-    all information about GESTimelineElement position in the timeline
-
--   GESVideoSource now auto orientates the images if it is defined in a
-    meta (overridable).
-
--   Added some PyGObject overrides to make the API more pythonic
-
--   The threading model has been made more explicit with safe guard to
-    make sure not thread safe APIs are not used from the wrong threads.
-    It is also now possible to properly handle in what thread the API
-    should be used.
-
--   Optimized GESClip and GESTrackElement creation
-
--   Added a way to compile out the old, unused and deprecated
-    GESPitiviFormatter
-
--   Re implemented the timeline editing API making it faster and making
-    the code much more maintainable
-
--   Simplified usage of nlecomposition outside GES by removing quirks in
-    it API usage and removing the need to treat it specially from an
-    application perspective.
-
--   ges-launch-1.0:
-
-    -   Added support to add titles to the timeline
-    -   Enhance the help auto generating it from the code
-
--   Deprecate ges_timeline_load_from_uri as loading the timeline should
-    be done through a project now
-
--   MANY leaks have been plugged and the unit testsuite is now “leak
-    free”
+-   FIXME
 
 
 GStreamer validate
 
--   Added an action type to verify the checksum of the sink last-sample
-
--   Added an include keyword to validate scenarios
-
--   Added the notion of variable in scenarios, with the set-vars keyword
-
--   Started adding support for “performance” like tests by allowing to
-    define the number of dropped buffers or the minimum buffer frequency
-    on a specific pad
-
--   Added a validateflow plugin which allows defining the data flow to
-    be seen on a particular pad and verifying that following runs match
-    the expectations
-
--   Added support for appsrc based test definition so we can instrument
-    the data pushed into the pipeline from scenarios
-
--   Added a mockdecryptor allowing adding tests with on encrypted files,
-    the element will potentially be instrumented with a validate
-    scenario
-
--   gst-validate-launcher:
-
-    -   Cleaned up output
-
-    -   Changed the default for “muting” tests as user doesn’t expect
-        hundreds of windows to show up when running the testsuite
-
-    -   Fixed the outputted xunit files to be compatible with GitLab
-
-    -   Added support to run tests on media files in push mode (using
-        pushfile://)
-
-    -   Added support for running inside gst-build
-
-    -   Added support for running ssim tests on rendered files
-
-    -   Added a way to simply define tests on pipelines through a simple
-        .json file
-
-    -   Added a python app to easily run python testsuite reusing all
-        the launcher features
-
-    -   Added flatpak knowledge so we can print backtrace even when
-        running from within flatpak
-
-    -   Added a way to automatically generated “known issues”
-        suppressions lines
-
-    -   Added a way to rerun tests to check if they are flaky and added
-        a way to tolerate tests known to be flaky
-
-    -   Add a way to output html log files
+-   FIXME
 
 
 GStreamer Python Bindings
 
--   add binding for gst_pad_set_caps()
-
--   pygobject dependency requirement was bumped to >= 3.8
-
--   new audiotestsrc, audioplot, and mixer plugin examples, and a
-    dynamic pipeline example
+-   FIXME
 
 
 GStreamer C# Bindings
 
--   bindings for the GstWebRTC library
+-   FIXME
 
 
 GStreamer Rust Bindings
 
-The GStreamer Rust bindings are now officially part of the GStreamer
-project and are also maintained in the GStreamer GitLab.
-
-The releases will generally not be synchronized with the releases of
-other GStreamer parts due to dependencies on other projects.
-
-Also unlike the other GStreamer libraries, the bindings will not commit
-to full API stability but instead will follow the approach that is
-generally taken by Rust projects, e.g.:
-
-1)  0.12.X will be completely API compatible with all other 0.12.Y
-    versions.
-2)  0.12.X+1 will contain bugfixes and compatible new feature additions.
-3)  0.13.0 will _not_ be backwards compatible with 0.12.X but projects
-    will be able to stay at 0.12.X without any problems as long as they
-    don’t need newer features.
-
-The current stable release is 0.12.2 and the next release series will be
-0.13, probably around March 2019.
-
-At this point the bindings cover most of GStreamer core (except for most
-notably GstAllocator and GstMemory), and most parts of the app, audio,
-base, check, editing-services, gl, net. pbutils, player, rtsp,
-rtsp-server, sdp, video and webrtc libraries.
-
-Also included is support for creating subclasses of the following types
-and writing GStreamer plugins:
-
--   gst::Element
--   gst::Bin and gst::Pipeline
--   gst::URIHandler and gst::ChildProxy
--   gst::Pad, gst::GhostPad
--   gst_base::Aggregator and gst_base::AggregatorPad
--   gst_base::BaseSrc and gst_base::BaseSink
--   gst_base::BaseTransform
-
-Changes to 0.12.X since 0.12.0
-
-Fixed
-
--   PTP clock constructor actually creates a PTP instead of NTP clock
-
-Added
-
--   Bindings for GStreamer Editing Services
--   Bindings for GStreamer Check testing library
--   Bindings for the encoding profile API (encodebin)
-
--   VideoFrame, VideoInfo, AudioInfo, StructureRef implements Send and
-    Sync now
--   VideoFrame has a function to get the raw FFI pointer
--   From impls from the Error/Success enums to the combined enums like
-    FlowReturn
--   Bin-to-dot file functions were added to the Bin trait
--   gst_base::Adapter implements SendUnique now
--   More complete bindings for the gst_video::VideoOverlay interface,
-    especially
-    gst_video::is_video_overlay_prepare_window_handle_message()
-
-Changed
-
--   All references were updated from GitHub to freedesktop.org GitLab
--   Fix various links in the README.md
--   Link to the correct location for the documentation
--   Remove GitLab badge as that only works with gitlab.com currently
-
-Changes in git master for 0.13
-
-Fixed
-
--   gst::tag::Album is the album tag now instead of artist sortname
-
-Added
-
--   Subclassing infrastructure was moved directly into the bindings,
-    making the gst-plugin crate deprecated. This involves many API
-    changes but generally cleans up code and makes it more flexible.
-    Take a look at the gst-plugins-rs crate for various examples.
-
--   Bindings for CapsFeatures and Meta
--   Bindings for
-    ParentBufferMeta,VideoMetaandVideoOverlayCompositionMeta`
--   Bindings for VideoOverlayComposition and VideoOverlayRectangle
--   Bindings for VideoTimeCode
-
--   UniqueFlowCombiner and UniqueAdapter wrappers that make use of the
-    Rust compile-time mutability checks and expose more API in a safe
-    way, and as a side-effect implement Sync and Send now
-
--   More complete bindings for Allocation Query
--   pbutils functions for codec descriptions
--   TagList::iter() for iterating over all tags while getting a single
-    value per tag. The old ::iter_tag_list() function was renamed to
-    ::iter_generic() and still provides access to each value for a tag
--   Bus::iter() and Bus::iter_timed() iterators around the corresponding
-    ::pop\*() functions
-
--   serde serialization of Value can also handle Buffer now
-
--   Extensive comments to all examples with explanations
--   Transmuxing example showing how to use typefind, multiqueue and
-    dynamic pads
--   basic-tutorial-12 was ported and added
-
-Changed
-
--   Rust 1.31 is the minimum supported Rust version now
--   Update to latest gir code generator and glib bindings
-
--   Functions returning e.g. gst::FlowReturn or other “combined” enums
-    were changed to return split enums like
-    Result<gst::FlowSuccess, gst::FlowError> to allow usage of the
-    standard Rust error handling.
-
--   MiniObject subclasses are now newtype wrappers around the underlying
-    GstRc<FooRef> wrapper. This does not change the API in any breaking
-    way for the current usages, but allows MiniObjects to also be
-    implemented in other crates and makes sure rustdoc places the
-    documentation in the right places.
-
--   BinExt extension trait was renamed to GstBinExt to prevent conflicts
-    with gtk::Bin if both are imported
-
--   Buffer::from_slice() can’t possible return None
-
--   Various clippy warnings
+-   FIXME
 
 
 GStreamer Rust Plugins
 
-Like the GStreamer Rust bindings, the Rust plugins are now officially
-part of the GStreamer project and are also maintained in the GStreamer
-GitLab.
-
-In the 0.3.x versions this contained infrastructure for writing
-GStreamer plugins in Rust, and a set of plugins.
-
-In git master that infrastructure was moved to the GLib and GStreamer
-bindings directly, together with many other improvements that were made
-possible by this, so the gst-plugins-rs repository only contains
-GStreamer elements now.
-
-Elements included are:
-
--   Tutorials plugin: identity, rgb2gray and sinesrc with extensive
-    comments
-
--   rsaudioecho, a port of the audiofx element
-
--   rsfilesrc, rsfilesink
-
--   rsflvdemux, a FLV demuxer. Not feature-equivalent with flvdemux yet
-
--   threadshare plugin: ts-appsrc, ts-proxysrc/sink, ts-queue, ts-udpsrc
-    and ts-tcpclientsrc elements that use a fixed number of threads and
-    share them between instances. For more background about these
-    elements see Sebastian’s talk “When adding more threads adds more
-    problems - Thread-sharing between elements in GStreamer” at the
-    GStreamer Conference 2017.
+-   FIXME
 
--   rshttpsrc, a HTTP source around the hyper/reqwest Rust libraries.
-    Not feature-equivalent with souphttpsrc yet.
 
--   togglerecord, an element that allows to start/stop recording at any
-    time and keeps all audio/video streams in sync.
-
--   mccparse and mccenc, parsers and encoders for the MCC closed caption
-    file format.
-
-Changes to 0.3.X since 0.3.0
-
--   All references were updated from GitHub to freedesktop.org GitLab
--   Fix various links in the README.md
--   Link to the correct location for the documentation
-
-Changes in git master for 0.4
-
--   togglerecord: Switch to parking_lot crate for mutexes/condition
-    variables for lower overhead
--   Merge threadshare plugin here
--   New closedcaption plugin with mccparse and mccenc elements
--   New identity element for the tutorials plugin
-
--   Register plugins statically in tests instead of relying on the
-    plugin loader to find the shared library in a specific place
-
--   Update to the latest API changes in the GLib and GStreamer bindings
--   Update to the latest versions of all crates
+Build and Dependencies
 
+-   The Autotools build system has finally been removed in favour of the
+    Meson build system. Developers who currently use gst-uninstalled
+    should move to gst-build.
 
-Build and Dependencies
+-   API and plugin documentation are no longer built with gtk_doc. The
+    gtk_doc documentation has been removed in favour of a new unified
+    documentation module built with hotdoc. The intention is to
+    distribute the generated documentation in form of tarballs alongside
+    releases.
 
--   The MESON BUILD SYSTEM BUILD IS NOW FEATURE-COMPLETE (*) and it is
-    now the recommended build system on all platforms and also used by
-    Cerbero to build GStreamer on all platforms. The Autotools build is
-    scheduled to be removed in the next cycle. Developers who currently
-    use gst-uninstalled should move to gst-build. The build option
-    naming has been cleaned up and made consistent and there are now
-    feature options to enable/disable plugins and various other features
-    on a case-by-case basis. (*) with the exception of plugin docs which
-    will be handled differently in future
-
--   Symbol export in libraries is now controlled via explicit exports
-    using symbol visibility or export defines where supported, to ensure
-    consistency across all platforms. This also allows libraries to have
-    exports that vary based on detected platform features and configure
-    options as is the case with the GStreamer OpenGL integration library
-    for example. A few symbols that had been exported by accident in
-    earlier versions may no longer be exported. These symbols will not
-    have had declarations in any public header files then though and
-    would not have been usable.
-
--   The GStreamer FFmpeg wrapper plugin (gst-libav) now depends on
-    FFmpeg 4.x and uses the new FFmpeg 4.x API and stopped relying on
-    ancient API that was removed with the FFmpeg 4.x release. This means
-    that it is no longer possible to build this module against an older
-    system-provided FFmpeg 3.x version. Use the internal FFmpeg 4.x copy
-    instead if you build using autotools, or use gst-libav 1.14.x
-    instead which targets the FFmpeg 3.x API and _should_ work fine in
-    combination with a newer GStreamer. It’s difficult for us to support
-    both old and new FFmpeg APIs at the same time, apologies for any
-    inconvenience caused.
-
--   Hardware-accelerated Nvidia video encoder/decoder plugins nvdec and
-    nvenc can be built against CUDA Toolkit versions 9 and 10.0 now. The
-    dynlink interface has been dropped since it’s deprecated in 10.0.
-
--   The (optional) OpenCV requirement has been bumped to >= 3.0.0 and
-    the plugin can also be built against OpenCV 4.x now.
-
--   New sctp plugin based on usrsctp (for WebRTC data channels)
+-   FIXME
 
 Cerbero
 
@@ -1172,221 +175,66 @@ Windows, Android, iOS and macOS.
 
 Cerbero has seen a number of improvements:
 
--   Cerbero has been ported to Python 3 and requires Python 3.5 or newer
-    now
-
--   Source tarballs are now protected by checksums in the recipes to
-    guard against download errors and malicious takeover of projects or
-    websites. In addition, downloads are only allowed via secure
-    transports now and plain HTTP, FTP and git:// transports are not
-    allowed anymore.
-
--   There is now a new fetch-bootstrap command which downloads sources
-    required for bootstrapping, with an optional --build-tools-only
-    argument to match the bootstrap --build-tools-only command.
-
--   The bootstrap, build, package and bundle-source commands gained a
-    new --offline switch that ensures that only sources from the cache
-    are used and never downloaded via the network. This is useful in
-    combination with the fetch and fetch-bootstrap commands that acquire
-    sources ahead of time before any build steps are executed. This
-    allows more control over the sources used and when sources are
-    updated, and is particularly useful for build environments that
-    don’t have network access.
-
--   bootstrap --assume-yes will automatically say ‘yes’ to any
-    interactive prompts during the bootstrap stage, such as those from
-    apt-get or yum.
-
--   bootstrap --system-only will only bootstrap the system without build
-    tools.
-
--   Manifest support: The build manifest can be used in continuous
-    integration (CI) systems to fixate the Git revision of certain
-    projects so that all builds of a pipeline are on the same reference.
-    This is used in GStreamer’s gitlab CI for example. It can also be
-    used in order to re-produce a specific build. To set a manifest, you
-    can set manifest = 'my_manifest.xml' in your configuration file, or
-    use the --manifest command line option. The command line option will
-    take precendence over anything specific in the configuration file.
-
--   The new build-deps command can be used to build only the
-    dependencies of a recipe, without the recipe itself.
-
--   new --list-variants command to list available variants
-
--   variants can now be set on the command line via the -v option as a
-    comma-separated list. This overrides any variants set in any
-    configuration files.
-
--   new qt5, intelmsdk and nvidia variants for enabling Qt5 and hardware
-    codec support. See the Enabling Optional Features with Variants
-    section in the Cerbero documentation for more details how to enable
-    and use these variants.
-
--   A new -t / --timestamp command line switch makes commands print
-    timestamps
+-   FIXME
 
 
 Platform-specific changes and improvements
 
 Android
 
--   toolchain: update compiler to clang and NDKr18. NDK r18 removed the
-    armv5 target and only has Android platforms that target at least
-    armv7 so the armv5 target is not useful anymore.
-
--   The way that GIO modules are named has changed due to upstream GLib
-    natively adding support for loading static GIO modules. This means
-    that any GStreamer application using gnutls for SSL/TLS on the
-    Android or iOS platforms (or any other setup using static libraries)
-    will fail to link looking for the g_io_module_gnutls_load_static()
-    function. The new function name is now
-    g_io_gnutls_load(gpointer data). data can be NULL for a static
-    library. Look at this commit for the necessary change in the
-    examples.
-
--   various build issues on Android have been fixed.
+-   FIXME
 
 macOS and iOS
 
--   various build issues on iOS have been fixed.
-
--   the minimum required iOS version is now 9.0. The difference in
-    adoption between 8.0 and 9.0 is 0.1% and the bump to 9.0 fixes some
-    build issues.
-
--   The way that GIO modules are named has changed due to upstream GLib
-    natively adding support for loading static GIO modules. This means
-    that any GStreamer application using gnutls for SSL/TLS on the
-    Android or iOS platforms (or any other setup using static libraries)
-    will fail to link looking for the g_io_module_gnutls_load_static()
-    function. The new function name is now
-    g_io_gnutls_load(gpointer data). data can be NULL for a static
-    library. Look at this commit for the necessary change in the
-    examples.
+-   FIXME
 
 Windows
 
--   The webrtcdsp element is shipped again as part of the Windows binary
-    packages, the build system issue has been resolved.
-
--   ‘Inconsistent DLL linkage’ warnings when building with MSVC have
-    been fixed
-
--   Hardware-accelerated Nvidia video encoder/decoder plugins nvdec and
-    nvenc build on Windows now, also with MSVC and using Meson.
-
--   The ksvideosrc camera capture plugin supports 16-bit grayscale video
-    now
+-   toolchain upgrade
 
--   The wasapisrc audio capture element implements loopback recording
-    from another output device or sink
-
--   wasapisink recover from low buffer levels in shared mode and some
-    exclusive mode fixes
-
--   dshowsrc now implements the GstDeviceMonitor interface
+-   FIXME
 
 
 Contributors
 
-Aaron Boxer, Aleix Conchillo Flaqué, Alessandro Decina, Alexandru Băluț,
-Alex Ashley, Alexey Chernov, Alicia Boya García, Amit Pandya, Andoni
-Morales Alastruey, Andreas Frisch, Andre McCurdy, Andy Green, Anthony
-Violo, Antoine Jacoutot, Antonio Ospite, Arun Raghavan, Aurelien Jarno,
-Aurélien Zanelli, ayaka, Bananahemic, Bastian Köcher, Branko Subasic,
-Brendan Shanks, Carlos Rafael Giani, Charlie Turner, Christoph Reiter,
-Corentin Noël, Daeseok Youn, Damian Vicino, Dan Kegel, Daniel Drake,
-Daniel Klamt, Danilo Spinella, Dardo D Kleiner, David Ing, David
-Svensson Fors, Devarsh Thakkar, Dimitrios Katsaros, Edward Hervey,
-Emilio Pozuelo Monfort, Enrique Ocaña González, Erlend Eriksen, Ezequiel
-Garcia, Fabien Dessenne, Fabrizio Gennari, Florent Thiéry, Francisco
-Velazquez, Freyr666, Garima Gaur, Gary Bisson, George Kiagiadakis, Georg
-Lippitsch, Georg Ottinger, Geunsik Lim, Göran Jönsson, Guillaume
-Desmottes, H1Gdev, Haihao Xiang, Haihua Hu, Harshad Khedkar, Havard
-Graff, He Junyan, Hoonhee Lee, Hosang Lee, Hyunjun Ko, Ilya Smelykh,
-Ingo Randolf, Iñigo Huguet, Jakub Adam, James Stevenson, Jan Alexander
-Steffens, Jan Schmidt, Jerome Laheurte, Jimmy Ohn, Joakim Johansson,
-Jochen Henneberg, Johan Bjäreholt, John-Mark Bell, John Bassett, John
-Nikolaides, Jonathan Karlsson, Jonny Lamb, Jordan Petridis, Josep Torra,
-Joshua M. Doe, Jos van Egmond, Juan Navarro, Julian Bouzas, Jun Xie,
-Junyan He, Justin Kim, Kai Kang, Kim Tae Soo, Kirill Marinushkin, Kyrylo
-Polezhaiev, Lars Petter Endresen, Linus Svensson, Louis-Francis
-Ratté-Boulianne, Lucas Stach, Luis de Bethencourt, Luz Paz, Lyon Wang,
-Maciej Wolny, Marc-André Lureau, Marc Leeman, Marco Trevisan (Treviño),
-Marcos Kintschner, Marian Mihailescu, Marinus Schraal, Mark Nauwelaerts,
-Marouen Ghodhbane, Martin Kelly, Matej Knopp, Mathieu Duponchelle,
-Matteo Valdina, Matthew Waters, Matthias Fend, memeka, Michael Drake,
-Michael Gruner, Michael Olbrich, Michael Tretter, Miguel Paris, Mike
-Wey, Mikhail Fludkov, Naveen Cherukuri, Nicola Murino, Nicolas Dufresne,
-Niels De Graef, Nirbheek Chauhan, Norbert Wesp, Ognyan Tonchev, Olivier
-Crête, Omar Akkila, Pat DeSantis, Patricia Muscalu, Patrick Radizi,
-Patrik Nilsson, Paul Kocialkowski, Per Forlin, Peter Körner, Peter
-Seiderer, Petr Kulhavy, Philippe Normand, Philippe Renon, Philipp Zabel,
-Pierre Labastie, Piotr Drąg, Roland Jon, Roman Sivriver, Roman Shpuntov,
-Rosen Penev, Russel Winder, Sam Gigliotti, Santiago Carot-Nemesio,
-Sean-Der, Sebastian Dröge, Seungha Yang, Shi Yan, Sjoerd Simons, Snir
-Sheriber, Song Bing, Soon, Thean Siew, Sreerenj Balachandran, Stefan
-Ringel, Stephane Cerveau, Stian Selnes, Suhas Nayak, Takeshi Sato,
-Thiago Santos, Thibault Saunier, Thomas Bluemel, Tianhao Liu,
-Tim-Philipp Müller, Tobias Ronge, Tomasz Andrzejak, Tomislav Tustonić,
-U. Artie Eoff, Ulf Olsson, Varunkumar Allagadapa, Víctor Guzmán, Víctor
-Manuel Jáquez Leal, Vincenzo Bono, Vineeth T M, Vivia Nikolaidou, Wang
-Fei, wangzq, Whoopie, Wim Taymans, Wind Yuan, Wonchul Lee, Xabier
-Rodriguez Calvar, Xavier Claessens, Haihao Xiang, Yacine Bandou,
-Yeongjin Jeong, Yuji Kuwabara, Zeeshan Ali,
+-   FIXME
 
 … and many others who have contributed bug reports, translations, sent
 suggestions or helped testing.
 
 
-Stable 1.16 branch
+Stable 1.18 branch
 
-After the 1.16.0 release there will be several 1.16.x bug-fix releases
+After the 1.18.0 release there will be several 1.18.x bug-fix releases
 which will contain bug fixes which have been deemed suitable for a
 stable branch, but no new features or intrusive changes will be added to
-a bug-fix release usually. The 1.16.x bug-fix releases will be made from
-the git 1.16 branch, which is a stable branch.
+a bug-fix release usually. The 1.18.x bug-fix releases will be made from
+the git 1.18 branch, which will be a stable branch.
 
-1.16.0
+1.18.0
 
-1.16.0 was released on 19 April 2019.
+1.18.0 has not been released yet.
 
 
 Known Issues
 
--   possibly breaking/incompatible changes to properties of wrapped
-    FFmpeg decoders and encoders (see above).
-
--   The way that GIO modules are named has changed due to upstream GLib
-    natively adding support for loading static GIO modules. This means
-    that any GStreamer application using gnutls for SSL/TLS on the
-    Android or iOS platforms (or any other setup using static libraries)
-    will fail to link looking for the g_io_module_gnutls_load_static()
-    function. The new function name is now
-    g_io_gnutls_load(gpointer data). See Android/iOS sections above for
-    further details.
+-   FIXME
 
 
-Schedule for 1.18
+Schedule for 1.20
 
-Our next major feature release will be 1.18, and 1.17 will be the
-unstable development version leading up to the stable 1.18 release. The
-development of 1.17/1.18 will happen in the git master branch.
+Our next major feature release will be 1.20, and 1.19 will be the
+unstable development version leading up to the stable 1.20 release. The
+development of 1.19/1.20 will happen in the git master branch.
 
-The plan for the 1.18 development cycle is yet to be confirmed, but it
-is possible that the next cycle will be a short one in which case
-feature freeze would be perhaps around August 2019 with a new 1.18
-stable release in September.
+The plan for the 1.20 development cycle is yet to be confirmed.
 
-1.18 will be backwards-compatible to the stable 1.16, 1.14, 1.12, 1.10,
-1.8, 1.6, 1.4, 1.2 and 1.0 release series.
+1.20 will be backwards-compatible to the stable 1.18, 1.16, 1.14, 1.12,
+1.10, 1.8, 1.6, 1.4, 1.2 and 1.0 release series.
 
 ------------------------------------------------------------------------
 
 _These release notes have been prepared by Tim-Philipp Müller with_
-_contributions from Sebastian Dröge, Guillaume Desmottes, Matthew
-Waters, _ _Thibault Saunier, and Víctor Manuel Jáquez Leal._
+_contributions from … (FIXME)_
 
 _License: CC BY-SA 4.0_
diff --git a/RELEASE b/RELEASE
index 5cfe4dc..f5655c0 100644
--- a/RELEASE
+++ b/RELEASE
@@ -1,18 +1,15 @@
-This is GStreamer gst-libav 1.17.0.1.
+This is GStreamer gst-libav 1.17.1.
 
-The GStreamer team is thrilled to announce a new major feature release in the
-stable 1.0 API series of your favourite cross-platform multimedia framework!
+GStreamer 1.17 is the development branch leading up to the next major
+stable version which will be 1.18.
 
-As always, this release is again packed with new features, bug fixes and
-other improvements.
-
-The 1.16 release series adds new features on top of the 1.14 series and is
+The 1.17 development series adds new features on top of the 1.16 series and is
 part of the API and ABI-stable 1.x release series of the GStreamer multimedia
 framework.
 
 Full release notes will one day be found at:
 
-  https://gstreamer.freedesktop.org/releases/1.16/
+  https://gstreamer.freedesktop.org/releases/1.18/
 
 Binaries for Android, iOS, Mac OS X and Windows will usually be provided
 shortly after the release.
@@ -60,7 +57,7 @@ You can find source releases of gstreamer in the download
 directory: https://gstreamer.freedesktop.org/src/gstreamer/
 
 The git repository and details how to clone it can be found at
-https://cgit.freedesktop.org/gstreamer/gstreamer/
+https://gitlab.freedesktop.org/gstreamer/
 
 ==== Homepage ====
 
diff --git a/docs/gst_plugins_cache.json b/docs/gst_plugins_cache.json
index dcc4c22..167bc56 100644
--- a/docs/gst_plugins_cache.json
+++ b/docs/gst_plugins_cache.json
@@ -73723,903 +73723,1178 @@
                 "properties": {
                     "b-qfactor": {
                         "blurb": "QP factor between P- and B-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1.25",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "b-qoffset": {
                         "blurb": "QP offset between P- and B-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1.25",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "b-sensitivity": {
                         "blurb": "adjust sensitivity of b_frame_strategy 1 (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "40",
                         "max": "2147483647",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "b-strategy": {
                         "blurb": "strategy to choose between I/P/B-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "bidir-refine": {
                         "blurb": "refine the two motion vectors used in bidirectional macroblocks (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1",
                         "max": "4",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "bitrate": {
                         "blurb": "set bitrate (in bits/s) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "200000",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "bitrate-tolerance": {
                         "blurb": "Set video bitrate tolerance (in bits/s). In 1-pass mode, bitrate tolerance specifies how far ratecontrol is willing to deviate from the target average bitrate value. This is not related to minimum/maximum bitrate. Lowering tolerance too much has an adverse effect on quality. (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "4000000",
                         "max": "2147483647",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "brd-scale": {
                         "blurb": "downscale frames for dynamic B-frame decision (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "10",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "bufsize": {
                         "blurb": "set ratecontrol buffer size (in bits) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "chroma-sample-location": {
                         "blurb": "chroma sample location (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "unknown (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-chroma-sample-location-type",
                         "writable": true
                     },
                     "chromaoffset": {
                         "blurb": "chroma QP offset from luma (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "cmp": {
                         "blurb": "full-pel ME compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "sad (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "coder": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "vlc (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-coder",
                         "writable": true
                     },
                     "compression-level": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "-1",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "context": {
                         "blurb": "context model (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "dark-mask": {
                         "blurb": "compresses dark areas stronger than medium ones (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "dc": {
                         "blurb": "intra_dc_precision (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "16",
                         "min": "-8",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "dct": {
                         "blurb": "DCT algorithm (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "auto (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-dct",
                         "writable": true
                     },
                     "debug": {
                         "blurb": "print specific debug info (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "(none)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-debug",
                         "writable": true
                     },
                     "dia-size": {
                         "blurb": "diamond type & size for motion estimation (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "dump-separator": {
                         "blurb": "set information dump field separator (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "NULL",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gchararray",
                         "writable": true
                     },
                     "field-order": {
                         "blurb": "Field order (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "unknown (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-field-order",
                         "writable": true
                     },
                     "flags": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "(none)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-flags",
                         "writable": true
                     },
                     "flags2": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "(none)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-flags2",
                         "writable": true
                     },
                     "global-quality": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "gop-size": {
                         "blurb": "set the group of picture (GOP) size (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "12",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "i-qfactor": {
                         "blurb": "QP factor between P- and I-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "-0.8",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "i-qoffset": {
                         "blurb": "QP offset between P- and I-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "idct": {
                         "blurb": "select IDCT implementation (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "auto (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-idct",
                         "writable": true
                     },
                     "ildctcmp": {
                         "blurb": "interlaced DCT compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "vsad (8)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "keyint-min": {
                         "blurb": "minimum interval between IDR-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "25",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "last-pred": {
                         "blurb": "amount of motion predictors from the previous frame (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "lumi-mask": {
                         "blurb": "compresses bright areas stronger than medium ones (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "max-bframes": {
                         "blurb": "set maximum number of B-frames between non-B-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "max-pixels": {
                         "blurb": "Maximum number of pixels (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "2147483647",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint64",
                         "writable": true
                     },
                     "maxrate": {
                         "blurb": "maximum bitrate (in bits/s). Used for VBV together with bufsize. (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint64",
                         "writable": true
                     },
                     "mbcmp": {
                         "blurb": "macroblock compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "sad (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "mbd": {
                         "blurb": "macroblock decision algorithm (high quality mode) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "simple (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-mbd",
                         "writable": true
                     },
                     "mblmax": {
                         "blurb": "maximum macroblock Lagrange factor (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "3658",
                         "max": "32767",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "mblmin": {
                         "blurb": "minimum macroblock Lagrange factor (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "236",
                         "max": "32767",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "me-range": {
                         "blurb": "limit motion vectors range (1023 for DivX player) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "mepc": {
                         "blurb": "motion estimation bitrate penalty compensation (1.0 = 256) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "256",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
+                    "min-force-key-unit-interval": {
+                        "blurb": "Minimum interval between force-keyunit requests in nanoseconds",
+                        "conditionally-available": false,
+                        "construct": false,
+                        "construct-only": false,
+                        "controllable": false,
+                        "default": "0",
+                        "max": "18446744073709551615",
+                        "min": "0",
+                        "mutable": "null",
+                        "readable": true,
+                        "type": "guint64",
+                        "writable": true
+                    },
                     "minrate": {
                         "blurb": "minimum bitrate (in bits/s). Most useful in setting up a CBR encode. It is of little use otherwise. (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint64",
                         "writable": true
                     },
                     "mpeg-quant": {
                         "blurb": "use MPEG quantizers instead of H.263 (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "multipass-cache-file": {
                         "blurb": "Filename for multipass cache file",
+                        "conditionally-available": false,
                         "construct": true,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "stats.log",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gchararray",
                         "writable": true
                     },
                     "mv0-threshold": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "256",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "nr": {
                         "blurb": "noise reduction (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "nssew": {
                         "blurb": "nsse weight (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "8",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "omx-libname": {
                         "blurb": "OpenMAX library name (Private codec option)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "NULL",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gchararray",
                         "writable": true
                     },
                     "omx-libprefix": {
                         "blurb": "OpenMAX library prefix (Private codec option)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "NULL",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gchararray",
                         "writable": true
                     },
                     "p-mask": {
                         "blurb": "inter masking (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "pass": {
                         "blurb": "Encoding pass/type",
+                        "conditionally-available": false,
                         "construct": true,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "cbr (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "GstLibAVEncPass",
                         "writable": true
                     },
                     "pre-dia-size": {
                         "blurb": "diamond type & size for motion estimation pre-pass (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "precmp": {
                         "blurb": "pre motion estimation compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "sad (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "pred": {
                         "blurb": "prediction method (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "left (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-pred",
                         "writable": true
                     },
                     "preme": {
                         "blurb": "pre motion estimation (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "profile": {
                         "blurb": "Set the encoding profile (Private codec option)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "unknown (-99)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "h264-omx-profile",
                         "writable": true
                     },
                     "ps": {
                         "blurb": "RTP payload size in bytes (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "qblur": {
                         "blurb": "video quantizer scale blur (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0.5",
                         "max": "3.40282e+38",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "qcomp": {
                         "blurb": "video quantizer scale compression (VBR). Constant of ratecontrol equation. Recommended range for default rc_eq: 0.0-1.0 (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0.5",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "qdiff": {
                         "blurb": "maximum difference between the quantizer scales (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "3",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "qmax": {
                         "blurb": "maximum video quantizer scale (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "31",
                         "max": "1024",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "qmin": {
                         "blurb": "minimum video quantizer scale (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "2",
                         "max": "69",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "qos": {
                         "blurb": "Handle Quality-of-Service events from downstream",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "false",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gboolean",
                         "writable": true
                     },
                     "quantizer": {
                         "blurb": "Constant Quantizer",
+                        "conditionally-available": false,
                         "construct": true,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0.01",
                         "max": "30",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "rc-init-occupancy": {
                         "blurb": "number of bits which should be loaded into the rc buffer before decoding starts (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "rc-max-vbv-use": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "rc-min-vbv-use": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "3",
                         "max": "3.40282e+38",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "refs": {
                         "blurb": "reference frames to consider for motion compensation (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "sc-threshold": {
                         "blurb": "scene change threshold (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "scplx-mask": {
                         "blurb": "spatial complexity masking (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "side-data-only-packets": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "true",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gboolean",
                         "writable": true
                     },
                     "skip-exp": {
                         "blurb": "frame skip exponent (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "skip-factor": {
                         "blurb": "frame skip factor (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "skip-threshold": {
                         "blurb": "frame skip threshold (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "skipcmp": {
                         "blurb": "frame skip compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "dctmax (13)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "slices": {
                         "blurb": "set the number of slices, used in parallelized encoding (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "strict": {
                         "blurb": "how strictly to follow the standards (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "normal (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-strict",
                         "writable": true
                     },
                     "subcmp": {
                         "blurb": "sub-pel ME compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "sad (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "subq": {
                         "blurb": "sub-pel motion estimation quality (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "8",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "tcplx-mask": {
                         "blurb": "temporal complexity masking (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "thread-type": {
                         "blurb": "select multithreading type (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "slice+frame",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-thread-type",
                         "writable": true
                     },
                     "threads": {
                         "blurb": "set the number of threads (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "unknown (1)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-threads",
                         "writable": true
                     },
                     "ticks-per-frame": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1",
                         "max": "2147483647",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "timecode-frame-start": {
                         "blurb": "GOP timecode frame start number, in non-drop-frame format (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "18446744073709551615",
                         "max": "9223372036854775807",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint64",
                         "writable": true
                     },
                     "trellis": {
                         "blurb": "rate-distortion optimal quantization (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "zerocopy": {
                         "blurb": "Try to avoid copying input frames if possible (Private codec option)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "1",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
@@ -74658,894 +74933,1166 @@
                 "properties": {
                     "b-qfactor": {
                         "blurb": "QP factor between P- and B-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1.25",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "b-qoffset": {
                         "blurb": "QP offset between P- and B-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1.25",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "b-sensitivity": {
                         "blurb": "adjust sensitivity of b_frame_strategy 1 (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "40",
                         "max": "2147483647",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "b-strategy": {
                         "blurb": "strategy to choose between I/P/B-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "bidir-refine": {
                         "blurb": "refine the two motion vectors used in bidirectional macroblocks (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1",
                         "max": "4",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "bitrate": {
                         "blurb": "set bitrate (in bits/s) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "200000",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "bitrate-tolerance": {
                         "blurb": "Set video bitrate tolerance (in bits/s). In 1-pass mode, bitrate tolerance specifies how far ratecontrol is willing to deviate from the target average bitrate value. This is not related to minimum/maximum bitrate. Lowering tolerance too much has an adverse effect on quality. (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "4000000",
                         "max": "2147483647",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "brd-scale": {
                         "blurb": "downscale frames for dynamic B-frame decision (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "10",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "bufsize": {
                         "blurb": "set ratecontrol buffer size (in bits) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "chroma-sample-location": {
                         "blurb": "chroma sample location (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "unknown (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-chroma-sample-location-type",
                         "writable": true
                     },
                     "chromaoffset": {
                         "blurb": "chroma QP offset from luma (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "chunks": {
                         "blurb": "chunk count (Private codec option)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1",
                         "max": "64",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "cmp": {
                         "blurb": "full-pel ME compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "sad (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "coder": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "vlc (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-coder",
                         "writable": true
                     },
                     "compression-level": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "-1",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "compressor": {
                         "blurb": "second-stage compressor (Private codec option)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "snappy (176)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "hap-encoder-compressor",
                         "writable": true
                     },
                     "context": {
                         "blurb": "context model (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "dark-mask": {
                         "blurb": "compresses dark areas stronger than medium ones (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "dc": {
                         "blurb": "intra_dc_precision (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "16",
                         "min": "-8",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "dct": {
                         "blurb": "DCT algorithm (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "auto (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-dct",
                         "writable": true
                     },
                     "debug": {
                         "blurb": "print specific debug info (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "(none)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-debug",
                         "writable": true
                     },
                     "dia-size": {
                         "blurb": "diamond type & size for motion estimation (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "dump-separator": {
                         "blurb": "set information dump field separator (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "NULL",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gchararray",
                         "writable": true
                     },
                     "field-order": {
                         "blurb": "Field order (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "unknown (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-field-order",
                         "writable": true
                     },
                     "flags": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "(none)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-flags",
                         "writable": true
                     },
                     "flags2": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "(none)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-flags2",
                         "writable": true
                     },
                     "format": {
                         "blurb": "(null) (Private codec option)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "hap (11)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "hap-encoder-format",
                         "writable": true
                     },
                     "global-quality": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "gop-size": {
                         "blurb": "set the group of picture (GOP) size (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "12",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "i-qfactor": {
                         "blurb": "QP factor between P- and I-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "-0.8",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "i-qoffset": {
                         "blurb": "QP offset between P- and I-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "idct": {
                         "blurb": "select IDCT implementation (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "auto (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-idct",
                         "writable": true
                     },
                     "ildctcmp": {
                         "blurb": "interlaced DCT compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "vsad (8)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "keyint-min": {
                         "blurb": "minimum interval between IDR-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "25",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "last-pred": {
                         "blurb": "amount of motion predictors from the previous frame (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "lumi-mask": {
                         "blurb": "compresses bright areas stronger than medium ones (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "max-bframes": {
                         "blurb": "set maximum number of B-frames between non-B-frames (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "max-pixels": {
                         "blurb": "Maximum number of pixels (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "2147483647",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint64",
                         "writable": true
                     },
                     "maxrate": {
                         "blurb": "maximum bitrate (in bits/s). Used for VBV together with bufsize. (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint64",
                         "writable": true
                     },
                     "mbcmp": {
                         "blurb": "macroblock compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "sad (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "mbd": {
                         "blurb": "macroblock decision algorithm (high quality mode) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "simple (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-mbd",
                         "writable": true
                     },
                     "mblmax": {
                         "blurb": "maximum macroblock Lagrange factor (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "3658",
                         "max": "32767",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "mblmin": {
                         "blurb": "minimum macroblock Lagrange factor (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "236",
                         "max": "32767",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "me-range": {
                         "blurb": "limit motion vectors range (1023 for DivX player) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "mepc": {
                         "blurb": "motion estimation bitrate penalty compensation (1.0 = 256) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "256",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
+                    "min-force-key-unit-interval": {
+                        "blurb": "Minimum interval between force-keyunit requests in nanoseconds",
+                        "conditionally-available": false,
+                        "construct": false,
+                        "construct-only": false,
+                        "controllable": false,
+                        "default": "0",
+                        "max": "18446744073709551615",
+                        "min": "0",
+                        "mutable": "null",
+                        "readable": true,
+                        "type": "guint64",
+                        "writable": true
+                    },
                     "minrate": {
                         "blurb": "minimum bitrate (in bits/s). Most useful in setting up a CBR encode. It is of little use otherwise. (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint64",
                         "writable": true
                     },
                     "mpeg-quant": {
                         "blurb": "use MPEG quantizers instead of H.263 (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "multipass-cache-file": {
                         "blurb": "Filename for multipass cache file",
+                        "conditionally-available": false,
                         "construct": true,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "stats.log",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gchararray",
                         "writable": true
                     },
                     "mv0-threshold": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "256",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "nr": {
                         "blurb": "noise reduction (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "nssew": {
                         "blurb": "nsse weight (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "8",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "p-mask": {
                         "blurb": "inter masking (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "pass": {
                         "blurb": "Encoding pass/type",
+                        "conditionally-available": false,
                         "construct": true,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "cbr (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "GstLibAVEncPass",
                         "writable": true
                     },
                     "pre-dia-size": {
                         "blurb": "diamond type & size for motion estimation pre-pass (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "precmp": {
                         "blurb": "pre motion estimation compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "sad (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "pred": {
                         "blurb": "prediction method (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "left (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-pred",
                         "writable": true
                     },
                     "preme": {
                         "blurb": "pre motion estimation (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "ps": {
                         "blurb": "RTP payload size in bytes (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "qblur": {
                         "blurb": "video quantizer scale blur (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0.5",
                         "max": "3.40282e+38",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "qcomp": {
                         "blurb": "video quantizer scale compression (VBR). Constant of ratecontrol equation. Recommended range for default rc_eq: 0.0-1.0 (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0.5",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "qdiff": {
                         "blurb": "maximum difference between the quantizer scales (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "3",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "qmax": {
                         "blurb": "maximum video quantizer scale (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "31",
                         "max": "1024",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "qmin": {
                         "blurb": "minimum video quantizer scale (VBR) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "2",
                         "max": "69",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "qos": {
                         "blurb": "Handle Quality-of-Service events from downstream",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "false",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gboolean",
                         "writable": true
                     },
                     "quantizer": {
                         "blurb": "Constant Quantizer",
+                        "conditionally-available": false,
                         "construct": true,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0.01",
                         "max": "30",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "rc-init-occupancy": {
                         "blurb": "number of bits which should be loaded into the rc buffer before decoding starts (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "rc-max-vbv-use": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "rc-min-vbv-use": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "3",
                         "max": "3.40282e+38",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "refs": {
                         "blurb": "reference frames to consider for motion compensation (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "sc-threshold": {
                         "blurb": "scene change threshold (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "scplx-mask": {
                         "blurb": "spatial complexity masking (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "side-data-only-packets": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "true",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gboolean",
                         "writable": true
                     },
                     "skip-exp": {
                         "blurb": "frame skip exponent (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "skip-factor": {
                         "blurb": "frame skip factor (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "skip-threshold": {
                         "blurb": "frame skip threshold (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "skipcmp": {
                         "blurb": "frame skip compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "dctmax (13)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "slices": {
                         "blurb": "set the number of slices, used in parallelized encoding (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "strict": {
                         "blurb": "how strictly to follow the standards (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "normal (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-strict",
                         "writable": true
                     },
                     "subcmp": {
                         "blurb": "sub-pel ME compare function (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "sad (0)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-cmp-func",
                         "writable": true
                     },
                     "subq": {
                         "blurb": "sub-pel motion estimation quality (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "8",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "tcplx-mask": {
                         "blurb": "temporal complexity masking (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "3.40282e+38",
                         "min": "-3.40282e+38",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gfloat",
                         "writable": true
                     },
                     "thread-type": {
                         "blurb": "select multithreading type (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "slice+frame",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-thread-type",
                         "writable": true
                     },
                     "threads": {
                         "blurb": "set the number of threads (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "unknown (1)",
+                        "mutable": "null",
                         "readable": true,
                         "type": "avcodeccontext-threads",
                         "writable": true
                     },
                     "ticks-per-frame": {
                         "blurb": "(null) (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "1",
                         "max": "2147483647",
                         "min": "1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "timecode-frame-start": {
                         "blurb": "GOP timecode frame start number, in non-drop-frame format (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "18446744073709551615",
                         "max": "9223372036854775807",
                         "min": "-1",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint64",
                         "writable": true
                     },
                     "trellis": {
                         "blurb": "rate-distortion optimal quantization (Generic codec option, might have no effect)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "-2147483648",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
@@ -134887,22 +135434,28 @@
                 "properties": {
                     "maxdelay": {
                         "blurb": "Set the maximum demux-decode delay (in microseconds)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
                     },
                     "preload": {
                         "blurb": "Set the initial demux-decode delay (in microseconds)",
+                        "conditionally-available": false,
                         "construct": false,
                         "construct-only": false,
+                        "controllable": false,
                         "default": "0",
                         "max": "2147483647",
                         "min": "0",
+                        "mutable": "null",
                         "readable": true,
                         "type": "gint",
                         "writable": true
@@ -143064,7 +143617,7 @@
                 ]
             }
         },
-        "package": "GStreamer FFMPEG Plug-ins git",
+        "package": "GStreamer FFMPEG Plug-ins",
         "source": "gst-libav",
         "tracers": {},
         "url": "Unknown package origin"
diff --git a/gst-libav.doap b/gst-libav.doap
index 3ce1c41..68f1114 100644
--- a/gst-libav.doap
+++ b/gst-libav.doap
@@ -18,7 +18,7 @@ contains most popular decoders as well as very fast
 colorspace conversion elements.
  </description>
  <category></category>
- <bug-database rdf:resource="http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer&amp;component=gst-libav" />
+ <bug-database rdf:resource="https://gitlab.freedesktop.org/gstreamer/gst-libav/issues/" />
  <screenshots></screenshots>
  <mailing-list rdf:resource="http://lists.freedesktop.org/mailman/listinfo/gstreamer-devel" />
  <programming-language>C</programming-language>
@@ -34,6 +34,16 @@ colorspace conversion elements.
 
  <release>
   <Version>
+   <revision>1.17.1</revision>
+   <branch>master</branch>
+   <name></name>
+   <created>2020-06-19</created>
+   <file-release rdf:resource="https://gstreamer.freedesktop.org/src/gst-libav/gst-libav-1.17.1.tar.xz" />
+  </Version>
+ </release>
+
+ <release>
+  <Version>
    <revision>1.16.0</revision>
    <branch>master</branch>
    <name></name>
diff --git a/meson.build b/meson.build
index 95aea47..47dd17e 100644
--- a/meson.build
+++ b/meson.build
@@ -1,5 +1,5 @@
 project('gst-libav', 'c', 'cpp',
-  version : '1.17.0.1',
+  version : '1.17.1',
   meson_version : '>= 0.48.0',
   default_options : [ 'warning_level=1',
                       'buildtype=debugoptimized' ])