Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package gstreamer-plugins-good for openSUSE:Factory checked in at 2021-01-20 18:23:46 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/gstreamer-plugins-good (Old) and /work/SRC/openSUSE:Factory/.gstreamer-plugins-good.new.28504 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "gstreamer-plugins-good" Wed Jan 20 18:23:46 2021 rev:75 rq:864314 version:1.18.3 Changes: -------- --- /work/SRC/openSUSE:Factory/gstreamer-plugins-good/gstreamer-plugins-good.changes 2020-12-12 20:27:38.849557343 +0100 +++ /work/SRC/openSUSE:Factory/.gstreamer-plugins-good.new.28504/gstreamer-plugins-good.changes 2021-01-20 18:24:26.599353934 +0100 @@ -1,0 +2,11 @@ +Sat Jan 16 19:24:21 UTC 2021 - Bj??rn Lie <bjorn....@gmail.com> + +- Update to version 1.18.3: + + splitmuxsink: + - Avoid deadlock when releasing a pad from a running muxer + - Fix bogus fragment split + + v4l2object: Map correct video format for RGBA + + videoflip: fix possible crash when changing + video-direction/method while running + +------------------------------------------------------------------- Old: ---- gst-plugins-good-1.18.2.tar.xz New: ---- gst-plugins-good-1.18.3.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ gstreamer-plugins-good.spec ++++++ --- /var/tmp/diff_new_pack.VRq8Be/_old 2021-01-20 18:24:27.843354855 +0100 +++ /var/tmp/diff_new_pack.VRq8Be/_new 2021-01-20 18:24:27.847354857 +0100 @@ -1,7 +1,7 @@ # # spec file for package gstreamer-plugins-good # -# Copyright (c) 2020 SUSE LLC +# Copyright (c) 2021 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -29,7 +29,7 @@ %define ENABLE_EXPERIMENTAL 1 Name: gstreamer-plugins-good -Version: 1.18.2 +Version: 1.18.3 Release: 0 Summary: GStreamer Streaming-Media Framework Plug-Ins License: LGPL-2.1-or-later ++++++ _service ++++++ --- /var/tmp/diff_new_pack.VRq8Be/_old 2021-01-20 18:24:27.871354875 +0100 +++ /var/tmp/diff_new_pack.VRq8Be/_new 2021-01-20 18:24:27.875354878 +0100 @@ -9,7 +9,7 @@ <!-- <param name="changesgenerate">enable</param> --> - <param name="revision">1.18.2</param> + <param name="revision">1.18.3</param> <param name="scm">git</param> </service> <service name="recompress" mode="disabled"> ++++++ gst-plugins-good-1.18.2.tar.xz -> gst-plugins-good-1.18.3.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/ChangeLog new/gst-plugins-good-1.18.3/ChangeLog --- old/gst-plugins-good-1.18.2/ChangeLog 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/ChangeLog 2021-01-13 22:08:52.000000000 +0100 @@ -1,3 +1,115 @@ +=== release 1.18.3 === + +2021-01-13 21:08:50 +0000 Tim-Philipp M??ller <t...@centricular.com> + + * ChangeLog: + * NEWS: + * RELEASE: + * gst-plugins-good.doap: + * meson.build: + Release 1.18.3 + +2021-01-07 16:57:27 +0800 Hou Qi <qi....@nxp.com> + + * docs/gst_plugins_cache.json: + * sys/v4l2/gstv4l2object.c: + v4l2object: Map correct video format for RGBA + Map V4L2_PIX_FMT_RGBA32 pixel format to GST_VIDEO_FORMAT_RGBA instead of + GST_VIDEO_FORMAT_RGB video format to support RGBA. + Fixes #823 + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/851> + +2020-12-09 20:20:18 +1100 Matthew Waters <matt...@centricular.com> + + * docs/gst_plugins_cache.json: + * gst/videofilter/gstvideoflip.c: + * gst/videofilter/gstvideoflip.h: + * tests/check/elements/videoflip.c: + videoflip: fix possible crash when setting the video-direction while running + A classic case of not enough locking. + One interesting thing with this is the interaction between the + rotation value and caps negotiation. i.e. the width/height of the caps + can be swapped depending on the video-direction property. We can't lock + the entirety of the caps negotiation for obvious reasons so we need to + do something else. This takes the approach of trying to use a single + rotation value throughout the entirety of the negotiation and then + subsequent output frame in a kind of latching sequence. + Fixes: https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/issues/792 + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/847> + +2020-12-09 19:49:47 +1100 Matthew Waters <matt...@centricular.com> + + * tests/check/elements/videoflip.c: + * tests/check/meson.build: + tests: add tests for videoflip + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/847> + +2020-12-30 13:38:46 +0100 Ignacio Casal Quinteiro <qigna...@amazon.com> + + * gst/deinterlace/meson.build: + deinterlace: force -DPREFIX on macos + This is due to a bug in meson where it will not detect properly + the compiler if the symbols need an undercore. + https://github.com/mesonbuild/meson/issues/5482 + Fixes #821 + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/846> + +2020-12-10 14:27:49 +0200 Vivia Nikolaidou <vi...@ahiru.eu> + + * gst/multifile/gstsplitmuxsink.c: + * gst/multifile/gstsplitmuxsink.h: + splitmuxsink: Avoid deadlock when releasing a pad from a running muxer + Might not drain correctly + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/843> + +2020-12-12 03:28:56 +1100 Jan Schmidt <j...@centricular.com> + + * tests/check/elements/splitmuxsink.c: + splitmuxsink: Unit test - check format/opened/closed sequence + Check the sequence of format-location/fragment-opened/fragment-closed + events is respected. There should be 1 format-location call for each + fragment-opened message, and 1 fragment-closed for each. + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/840> + +2020-12-09 00:40:52 +1100 Jan Schmidt <j...@centricular.com> + + * gst/multifile/gstsplitmuxsink.c: + * gst/multifile/gstsplitmuxsink.h: + splitmuxsink: Fix for 'reference bytes muxed' check. + https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798 + introduced a check in the need-new-fragment logic to avoid starting a + new fragment unless there has been some data on the reference stream, + but the check is done against the number of bytes that have been + received on the input, not the number that were released for output + into the current fragment. + Fix the check to remember and test against bytes that have been sent + for output. + This also fixes a problem where starting a new fragment fails to + request a new filename from the format-location signal. + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/840> + +2020-09-15 00:27:24 +1000 Jan Schmidt <j...@centricular.com> + + * gst/multifile/gstsplitmuxsink.c: + splitmuxsink: Add debug for fragment opened/closed msgs + When posting fragment-opened and fragment-closed messages, + put a debug statement in the logs + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/840> + +2020-08-18 16:06:14 +1000 Jan Schmidt <j...@centricular.com> + + * gst/multifile/gstsplitmuxsink.c: + splitmuxsink: Convert asserts into element errors. + Change some g_assert into element errors so that they can be + caught and the pipeline shut down. + Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/840> + +2020-12-06 23:56:49 +0000 Tim-Philipp M??ller <t...@centricular.com> + + * docs/gst_plugins_cache.json: + * meson.build: + Back to development + === release 1.18.2 === 2020-12-06 13:22:58 +0000 Tim-Philipp M??ller <t...@centricular.com> @@ -5,6 +117,7 @@ * ChangeLog: * NEWS: * RELEASE: + * docs/gst_plugins_cache.json: * gst-plugins-good.doap: * meson.build: Release 1.18.2 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/NEWS new/gst-plugins-good-1.18.3/NEWS --- old/gst-plugins-good-1.18.2/NEWS 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/NEWS 2021-01-13 22:08:52.000000000 +0100 @@ -2,13 +2,13 @@ GStreamer 1.18.0 was originally released on 8 September 2020. -The latest bug-fix release in the 1.18 series is 1.18.2 and was released -on 6 December 2020. +The latest bug-fix release in the 1.18 series is 1.18.3 and was released +on 13 January 2021. See https://gstreamer.freedesktop.org/releases/1.18/ for the latest version of this document. -Last updated: Monday 26 October 2020, 11:00 UTC (log) +Last updated: Wednesday 13 January 2021, 20:00 UTC (log) Introduction @@ -2576,6 +2576,147 @@ - List of Merge Requests applied in 1.18.2 - List of Issues fixed in 1.18.2 +1.18.3 + +The third 1.18 bug-fix release (1.18.3) was released on 13 January 2021. + +This release only contains bugfixes and it should be safe to update from +1.18.x. + +Highlighted bugfixes in 1.18.3 + +- fix ogg playback regression for ogg files that also have ID3 or APE + tags +- compositor: fix artefacts and invalid memory access when blending + subsampled formats +- exported mini object ref/unref/copy functions for use in bindings + such as gstreamer-sharp +- Add support for Apple silicon (M1) to cerbero package builder +- Ship RIST plugin in binary packages +- various stability, performance and reliability improvements +- memory leak fixes +- build fixes + +gstreamer + +- gst: Add non-inline ref/unref/copy/replace methods for various mini + objects (buffer, bufferlist, caps, context, event, memory, message, + promise, query, sample, taglist, uri) for use in bindings such as + gstreamer-sharp +- harness: don???t use GST_DEBUG_OBJECT with GstHarness which is not a + GObject + +gst-plugins-base + +- audiorate: Make buffer writable before changing its metadata +- compositor: fix blending of subsampled components +- decodebin3: When reconfiguring a slot make sure that the ghostpad is + unlinked +- decodebin3: Release selection lock when pushing EOS +- encodebasebin: Ensure that parsers are compatible with selected + encoders +- tagdemux: resize and trim buffer in place to fix interaction with + oggdemux +- videoaggregator: Pop out old buffers on timeout +- video-blend: fix blending 8-bit and 16-bit frames together +- appsrc: fix signal documentation +- gl: document some GL caps specifics +- libvisual: workaround clang compiler warning + +gst-plugins-good + +- deinterlace: fix build of assembly optimisations on macOS +- splitmuxsink: Avoid deadlock when releasing a pad from a running + muxer +- splitmuxsink: fix bogus fragment split +- v4l2object: Map correct video format for RGBA +- videoflip: fix possible crash when changing video-direction/method + while running + +gst-plugins-bad + +- assrender: fix mutex handling in certain flushing/error situations +- dvbsuboverlay: Add support for dynamic resolution update +- dashsink: fix critical log of dynamic pipeline +- d3d11shader: Fix ID3DBlob object leak +- d3d11videosink: Prepare window once streaming started +- decklinkaudiosrc: Fix duration of the first audio frame after each + discont +- intervideosrc: fix negotiation of interlaced caps +- msdk: needn???t close mfx session when failed, fixes double free / + potential crash +- msdk: check GstMsdkContext instead of mfxSession instance +- srt: fix locking when retrieving stats +- rtmp2src: fix leaks when connection is cancelled during startup or + connection fails + +gst-plugins-ugly + +- no changes + +gst-libav + +- avauddec: Drain decoder on decoding failure, fixes timestamps after + decoding errors + +gst-rtsp-server + +- rtsp-media: Only count senders when counting blocked streams +- rtsp-client: Only unref client watch context on finalize, to avoid + deadlock + +gstreamer-vaapi + +- no changes + +gstreamer-sharp + +- no changes + +gst-omx + +- no changes + +gst-python + +- no changes + +gst-editing-services + +- launch: Ensure to add required ref to profiles from project +- tests: fix meson test env setup to make sure we use the right + gst-plugin-scanner + +gst-integration-testsuites + +- no changes + +gst-build + +- meson: Update zlib.wrap to use wrapdb instead of github fork + +Cerbero build tool and packaging changes in 1.18.3 + +- Add support for Apple silicon +- Build and ship RIST plugin + +Contributors to 1.18.3 + +Andoni Morales Alastruey, Edward Hervey, Haihao Xiang, Haihua Hu, Hou +Qi, Ignacio Casal Quinteiro, Jakub Adam, Jan Alexander Steffens +(heftig), Jan Schmidt, Jordan Petridis, Lawrence Troup, Lim Siew Hoon, +Mathieu Duponchelle, Matthew Waters, Nicolas Dufresne, Raju Babannavar, +Sebastian Dr??ge, Seungha Yang, Thibault Saunier, Tim-Philipp M??ller, +Tobias Ronge, Vivia Nikolaidou, + +??? and many others who have contributed bug reports, translations, sent +suggestions or helped testing. Thank you all! + +List of merge requests and issues fixed in 1.18.3 + +- List of Merge Requests applied in 1.18.3 +- List of Issues fixed in 1.18.3 + Schedule for 1.20 Our next major feature release will be 1.20, and 1.19 will be the @@ -2583,8 +2724,9 @@ development of 1.19/1.20 will happen in the git master branch. The plan for the 1.20 development cycle is yet to be confirmed, but it -is now expected that feature freeze will take place some time in January -2021, with the first 1.20 stable release around February/March 2021. +is now expected that feature freeze will take place some time in +January/February 2021, with the first 1.20 stable release hopefully +around February/March 2021. 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. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/RELEASE new/gst-plugins-good-1.18.3/RELEASE --- old/gst-plugins-good-1.18.2/RELEASE 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/RELEASE 2021-01-13 22:08:52.000000000 +0100 @@ -1,4 +1,4 @@ -This is GStreamer gst-plugins-good 1.18.2. +This is GStreamer gst-plugins-good 1.18.3. The GStreamer team is thrilled to announce a new major feature release of your favourite cross-platform multimedia framework! diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/docs/gst_plugins_cache.json new/gst-plugins-good-1.18.3/docs/gst_plugins_cache.json --- old/gst-plugins-good-1.18.2/docs/gst_plugins_cache.json 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/docs/gst_plugins_cache.json 2021-01-13 22:08:52.000000000 +0100 @@ -6595,7 +6595,7 @@ "construct": false, "construct-only": false, "controllable": false, - "default": "GStreamer 1.18.2 FLV muxer", + "default": "GStreamer 1.18.3 FLV muxer", "mutable": "null", "readable": true, "type": "gchararray", @@ -6607,7 +6607,7 @@ "construct": false, "construct-only": false, "controllable": false, - "default": "GStreamer 1.18.2 FLV muxer", + "default": "GStreamer 1.18.3 FLV muxer", "mutable": "null", "readable": true, "type": "gchararray", @@ -20636,7 +20636,7 @@ "construct": false, "construct-only": false, "controllable": false, - "default": "GStreamer/1.18.2", + "default": "GStreamer/1.18.3", "mutable": "null", "readable": true, "type": "gchararray", @@ -22593,7 +22593,7 @@ "construct": false, "construct-only": false, "controllable": false, - "default": "GStreamer souphttpsrc 1.18.2 ", + "default": "GStreamer souphttpsrc 1.18.3 ", "mutable": "null", "readable": true, "type": "gchararray", @@ -24203,7 +24203,7 @@ "long-name": "Video (video4linux2) Sink", "pad-templates": { "sink": { - "caps": "image/jpeg:\nvideo/mpeg:\n mpegversion: 4\n systemstream: false\nvideo/mpeg:\n mpegversion: { (int)1, (int)2 }\nvideo/mpegts:\n systemstream: true\nvideo/x-bayer:\n format: { bggr, gbrg, grbg, rggb }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-dv:\n systemstream: true\nvideo/x-fwht:\nvideo/x-h263:\n variant: itu\nvideo/x-h264:\n stream-format: { (string)byte-stream, (string)avc }\n alignment: au\nvideo/x-h265:\n stream-format: byte-stream\n alignment: au\nvideo/x-pwc1:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-pwc2:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-raw:\n format: { RGB16, BGR, ABGR, xBGR, RGBx, GRAY8, GRAY16_LE, GRAY16_BE, YVU9, YV12, YUY2, YVYU, UYVY, Y42B, Y41B, YUV9, NV12_64Z32, NV24, NV61, NV16, NV21, NV12, I420, ARGB, xRGB, RGB, BGRA, BGRx, BGR15, RGB15 }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-sonix:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-vp8:\nvideo/x-vp9:\nvideo/x-wmv:\n wmvversion: 3\n format: WVC1\n\nvideo/x-raw(format:Interlaced):\n format: { RGB16, BGR, ABGR, xBGR, RGBx, GRAY8, GRAY16_LE, GRAY16_BE, YVU9, YV12, YUY2, YVYU, UYVY, Y42B, Y41B, YUV9, NV12_64Z32, NV24, NV61, NV16, NV21, NV12, I420, ARGB, xRGB, RGB, BGRA, BGRx, BGR15, RGB15 }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\n interlace-mode: alternate\n", + "caps": "image/jpeg:\nvideo/mpeg:\n mpegversion: 4\n systemstream: false\nvideo/mpeg:\n mpegversion: { (int)1, (int)2 }\nvideo/mpegts:\n systemstream: true\nvideo/x-bayer:\n format: { bggr, gbrg, grbg, rggb }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-dv:\n systemstream: true\nvideo/x-fwht:\nvideo/x-h263:\n variant: itu\nvideo/x-h264:\n stream-format: { (string)byte-stream, (string)avc }\n alignment: au\nvideo/x-h265:\n stream-format: byte-stream\n alignment: au\nvideo/x-pwc1:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-pwc2:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-raw:\n format: { RGB16, BGR, RGB, ABGR, xBGR, RGBA, RGBx, GRAY8, GRAY16_LE, GRAY16_BE, YVU9, YV12, YUY2, YVYU, UYVY, Y42B, Y41B, YUV9, NV12_64Z32, N V24, NV61, NV16, NV21, NV12, I420, ARGB, xRGB, BGRA, BGRx, BGR15, RGB15 }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-sonix:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-vp8:\nvideo/x-vp9:\nvideo/x-wmv:\n wmvversion: 3\n format: WVC1\n\nvideo/x-raw(format:Interlaced):\n format: { RGB16, BGR, RGB, ABGR, xBGR, RGBA, RGBx, GRAY8, GRAY16_LE, GRAY16_BE, YVU9, YV12, YUY2, YVYU, UYVY, Y42B, Y41B, YUV9, NV12_64Z32, NV24, NV61, NV16, NV21, NV12, I420, ARGB, xRGB, BGRA, BGRx, BGR15, RGB15 }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\n interlace-mode: alternate\n", "direction": "sink", "presence": "always" } @@ -24511,7 +24511,7 @@ "long-name": "Video (video4linux2) Source", "pad-templates": { "src": { - "caps": "image/jpeg:\nvideo/mpeg:\n mpegversion: 4\n systemstream: false\nvideo/mpeg:\n mpegversion: { (int)1, (int)2 }\nvideo/mpegts:\n systemstream: true\nvideo/x-bayer:\n format: { bggr, gbrg, grbg, rggb }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-dv:\n systemstream: true\nvideo/x-fwht:\nvideo/x-h263:\n variant: itu\nvideo/x-h264:\n stream-format: { (string)byte-stream, (string)avc }\n alignment: au\nvideo/x-h265:\n stream-format: byte-stream\n alignment: au\nvideo/x-pwc1:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-pwc2:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-raw:\n format: { RGB16, BGR, ABGR, xBGR, RGBx, GRAY8, GRAY16_LE, GRAY16_BE, YVU9, YV12, YUY2, YVYU, UYVY, Y42B, Y41B, YUV9, NV12_64Z32, NV24, NV61, NV16, NV21, NV12, I420, ARGB, xRGB, RGB, BGRA, BGRx, BGR15, RGB15 }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-sonix:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-vp8:\nvideo/x-vp9:\nvideo/x-wmv:\n wmvversion: 3\n format: WVC1\n\nvideo/x-raw(format:Interlaced):\n format: { RGB16, BGR, ABGR, xBGR, RGBx, GRAY8, GRAY16_LE, GRAY16_BE, YVU9, YV12, YUY2, YVYU, UYVY, Y42B, Y41B, YUV9, NV12_64Z32, NV24, NV61, NV16, NV21, NV12, I420, ARGB, xRGB, RGB, BGRA, BGRx, BGR15, RGB15 }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\n interlace-mode: alternate\n", + "caps": "image/jpeg:\nvideo/mpeg:\n mpegversion: 4\n systemstream: false\nvideo/mpeg:\n mpegversion: { (int)1, (int)2 }\nvideo/mpegts:\n systemstream: true\nvideo/x-bayer:\n format: { bggr, gbrg, grbg, rggb }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-dv:\n systemstream: true\nvideo/x-fwht:\nvideo/x-h263:\n variant: itu\nvideo/x-h264:\n stream-format: { (string)byte-stream, (string)avc }\n alignment: au\nvideo/x-h265:\n stream-format: byte-stream\n alignment: au\nvideo/x-pwc1:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-pwc2:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-raw:\n format: { RGB16, BGR, RGB, ABGR, xBGR, RGBA, RGBx, GRAY8, GRAY16_LE, GRAY16_BE, YVU9, YV12, YUY2, YVYU, UYVY, Y42B, Y41B, YUV9, NV12_64Z32, N V24, NV61, NV16, NV21, NV12, I420, ARGB, xRGB, BGRA, BGRx, BGR15, RGB15 }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-sonix:\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\nvideo/x-vp8:\nvideo/x-vp9:\nvideo/x-wmv:\n wmvversion: 3\n format: WVC1\n\nvideo/x-raw(format:Interlaced):\n format: { RGB16, BGR, RGB, ABGR, xBGR, RGBA, RGBx, GRAY8, GRAY16_LE, GRAY16_BE, YVU9, YV12, YUY2, YVYU, UYVY, Y42B, Y41B, YUV9, NV12_64Z32, NV24, NV61, NV16, NV21, NV12, I420, ARGB, xRGB, BGRA, BGRx, BGR15, RGB15 }\n width: [ 1, 32768 ]\n height: [ 1, 32768 ]\n framerate: [ 0/1, 2147483647/1 ]\n interlace-mode: alternate\n", "direction": "src", "presence": "always" } @@ -25542,7 +25542,7 @@ "construct-only": false, "controllable": true, "default": "none (0)", - "mutable": "null", + "mutable": "playing", "readable": true, "type": "GstVideoFlipMethod", "writable": true diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/gst/deinterlace/meson.build new/gst-plugins-good-1.18.3/gst/deinterlace/meson.build --- old/gst-plugins-good-1.18.2/gst/deinterlace/meson.build 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/gst/deinterlace/meson.build 2021-01-13 22:08:52.000000000 +0100 @@ -49,7 +49,12 @@ endif # Assembly has to be told when the symbols have to be prefixed with _ - if cc.symbols_have_underscore_prefix() + # Note that symbols_have_underscore_prefix does not work properly on macos + # if the compiler -g flag is used. See: + # https://github.com/mesonbuild/meson/issues/5482 + if ['darwin', 'ios'].contains(host_system) + asm_prefix_def = '-DPREFIX' + elif cc.symbols_have_underscore_prefix() asm_prefix_def = '-DPREFIX' else asm_prefix_def = '-UPREFIX' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/gst/multifile/gstsplitmuxsink.c new/gst-plugins-good-1.18.3/gst/multifile/gstsplitmuxsink.c --- old/gst-plugins-good-1.18.2/gst/multifile/gstsplitmuxsink.c 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/gst/multifile/gstsplitmuxsink.c 2021-01-13 22:08:52.000000000 +0100 @@ -1108,6 +1108,9 @@ "location") != NULL) g_object_get (sink, "location", &location, NULL); + GST_DEBUG_OBJECT (splitmux, + "Sending %s message. Running time %" GST_TIME_FORMAT " location %s", + msg_name, GST_TIME_ARGS (running_time), GST_STR_NULL (location)); /* If it's in the middle of a teardown, the reference_ctc might have become * NULL */ @@ -1318,8 +1321,13 @@ grow_blocked_queues (splitmux); if (cmd->start_new_fragment) { - GST_DEBUG_OBJECT (splitmux, "Got cmd to start new fragment"); - splitmux->output_state = SPLITMUX_OUTPUT_STATE_ENDING_FILE; + if (splitmux->muxed_out_bytes > 0) { + GST_DEBUG_OBJECT (splitmux, "Got cmd to start new fragment"); + splitmux->output_state = SPLITMUX_OUTPUT_STATE_ENDING_FILE; + } else { + GST_DEBUG_OBJECT (splitmux, + "Got cmd to start new fragment, but fragment is empty - ignoring."); + } } else { GST_DEBUG_OBJECT (splitmux, "Got new output cmd for time %" GST_STIME_FORMAT, @@ -2016,9 +2024,7 @@ } GST_SPLITMUX_LOCK (splitmux); - if (splitmux->muxed_out_bytes > 0 - || splitmux->fragment_id == splitmux->start_index) - set_next_filename (splitmux, ctx); + set_next_filename (splitmux, ctx); splitmux->muxed_out_bytes = 0; GST_SPLITMUX_UNLOCK (splitmux); @@ -2207,8 +2213,11 @@ /* Have we muxed at least one thing from the reference * stream into the file? If not, no other streams can have * either */ - if (splitmux->fragment_reference_bytes <= 0) + if (splitmux->fragment_reference_bytes <= 0) { + GST_TRACE_OBJECT (splitmux, + "Not ready to split - nothing muxed on the reference stream"); return FALSE; + } /* User told us to split now */ if (g_atomic_int_get (&(splitmux->do_split_next_gop)) == TRUE) { @@ -2231,6 +2240,10 @@ gst_queue_array_pop_head_struct (splitmux->times_to_split); ptr_to_time = gst_queue_array_peek_head_struct (splitmux->times_to_split); } + GST_TRACE_OBJECT (splitmux, + "GOP start time %" GST_STIME_FORMAT " is after requested split point %" + GST_STIME_FORMAT, GST_STIME_ARGS (splitmux->gop_start_time), + GST_STIME_ARGS (time_to_split)); GST_OBJECT_UNLOCK (splitmux); return TRUE; } @@ -2339,9 +2352,18 @@ splitmux->reference_ctx->in_running_time - splitmux->gop_start_time; GST_LOG_OBJECT (splitmux, " queued_bytes %" G_GUINT64_FORMAT, queued_bytes); + GST_LOG_OBJECT (splitmux, "mq at TS %" GST_STIME_FORMAT + " bytes %" G_GUINT64_FORMAT " in running time %" GST_STIME_FORMAT + " gop start time %" GST_STIME_FORMAT, + GST_STIME_ARGS (queued_time), queued_bytes, + GST_STIME_ARGS (splitmux->reference_ctx->in_running_time), + GST_STIME_ARGS (splitmux->gop_start_time)); - g_assert (queued_gop_time >= 0); - g_assert (queued_time >= splitmux->fragment_start_time); + if (queued_gop_time < 0) + goto error_gop_duration; + + if (queued_time < splitmux->fragment_start_time) + goto error_queued_time; queued_time -= splitmux->fragment_start_time; if (queued_time < queued_gop_time) @@ -2350,13 +2372,6 @@ /* Expand queued bytes estimate by muxer overhead */ queued_bytes += (queued_bytes * splitmux->mux_overhead); - GST_LOG_OBJECT (splitmux, "mq at TS %" GST_STIME_FORMAT - " bytes %" G_GUINT64_FORMAT " in running time %" GST_STIME_FORMAT - " gop start time %" GST_STIME_FORMAT, - GST_STIME_ARGS (queued_time), queued_bytes, - GST_STIME_ARGS (splitmux->reference_ctx->in_running_time), - GST_STIME_ARGS (splitmux->gop_start_time)); - /* Check for overrun - have we output at least one byte and overrun * either threshold? */ if (need_new_fragment (splitmux, queued_time, queued_gop_time, queued_bytes)) { @@ -2416,6 +2431,7 @@ /* Now either way - either there was no overflow, or we requested a new fragment: release this GOP */ splitmux->fragment_total_bytes += splitmux->gop_total_bytes; + splitmux->fragment_reference_bytes += splitmux->gop_reference_bytes; if (splitmux->gop_total_bytes > 0) { GST_LOG_OBJECT (splitmux, @@ -2435,6 +2451,21 @@ } splitmux->gop_total_bytes = 0; + splitmux->gop_reference_bytes = 0; + return; + +error_gop_duration: + GST_ELEMENT_ERROR (splitmux, + STREAM, FAILED, ("Timestamping error on input streams"), + ("Queued GOP time is negative %" GST_STIME_FORMAT, + GST_STIME_ARGS (queued_gop_time))); + return; +error_queued_time: + GST_ELEMENT_ERROR (splitmux, + STREAM, FAILED, ("Timestamping error on input streams"), + ("Queued time is negative. Input went backwards. queued_time - %" + GST_STIME_FORMAT, GST_STIME_ARGS (queued_time))); + return; } /* Called with splitmux lock held */ @@ -2737,7 +2768,12 @@ switch (splitmux->input_state) { case SPLITMUX_INPUT_STATE_COLLECTING_GOP_START: - if (ctx->is_reference) { + if (ctx->is_releasing) { + /* The pad belonging to this context is being released */ + GST_WARNING_OBJECT (pad, "Pad is being released while the muxer is " + "running. Data might not drain correctly"); + loop_again = FALSE; + } else if (ctx->is_reference) { /* This is the reference context. If it's a keyframe, * it marks the start of a new GOP and we should wait in * check_completed_gop before continuing, but either way @@ -2825,7 +2861,7 @@ /* Update total input byte counter for overflow detect */ splitmux->gop_total_bytes += buf_info->buf_size; if (ctx->is_reference) { - splitmux->fragment_reference_bytes += buf_info->buf_size; + splitmux->gop_reference_bytes += buf_info->buf_size; } /* Now add this buffer to the queue just before returning */ @@ -3201,6 +3237,9 @@ GST_SPLITMUX_LOCK (splitmux); + ctx->is_releasing = TRUE; + GST_SPLITMUX_BROADCAST_INPUT (splitmux); + /* Can release the context now */ mq_stream_ctx_free (ctx); if (ctx == splitmux->reference_ctx) @@ -3223,6 +3262,10 @@ if (splitmux->contexts == NULL) gst_splitmux_reset_elements (splitmux); + /* Wake up other input streams to check if the completion conditions have + * changed */ + GST_SPLITMUX_BROADCAST_INPUT (splitmux); + fail: GST_SPLITMUX_UNLOCK (splitmux); } @@ -3523,6 +3566,7 @@ splitmux->fragment_total_bytes = 0; splitmux->fragment_reference_bytes = 0; splitmux->gop_total_bytes = 0; + splitmux->gop_reference_bytes = 0; splitmux->muxed_out_bytes = 0; splitmux->ready_for_output = FALSE; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/gst/multifile/gstsplitmuxsink.h new/gst-plugins-good-1.18.3/gst/multifile/gstsplitmuxsink.h --- old/gst-plugins-good-1.18.2/gst/multifile/gstsplitmuxsink.h 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/gst/multifile/gstsplitmuxsink.h 2021-01-13 22:08:52.000000000 +0100 @@ -85,6 +85,7 @@ gboolean out_eos_async_done; gboolean need_unblock; gboolean caps_change; + gboolean is_releasing; GstSegment in_segment; GstSegment out_segment; @@ -156,6 +157,9 @@ /* Number of bytes we've collected into * the GOP that's being collected */ guint64 gop_total_bytes; + /* Number of bytes from the reference context + * that we've collected into the current GOP */ + guint64 gop_reference_bytes; /* Start time of the current fragment */ GstClockTimeDiff fragment_start_time; /* Start time of the current GOP */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/gst/videofilter/gstvideoflip.c new/gst-plugins-good-1.18.3/gst/videofilter/gstvideoflip.c --- old/gst-plugins-good-1.18.2/gst/videofilter/gstvideoflip.c 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/gst/videofilter/gstvideoflip.c 2021-01-13 22:08:52.000000000 +0100 @@ -135,6 +135,26 @@ ret = gst_caps_copy (caps); + GST_OBJECT_LOCK (videoflip); + + if (videoflip->change_configuring_method) { + GEnumValue *configuring_method_enum, *method_enum; + GEnumClass *enum_class = + g_type_class_ref (GST_TYPE_VIDEO_ORIENTATION_METHOD); + + configuring_method_enum = + g_enum_get_value (enum_class, videoflip->configuring_method); + method_enum = g_enum_get_value (enum_class, videoflip->proposed_method); + GST_LOG_OBJECT (videoflip, + "Changing configuring method from %s to proposed %s", + configuring_method_enum ? configuring_method_enum->value_nick : "(nil)", + method_enum ? method_enum->value_nick : "(nil)"); + g_type_class_unref (enum_class); + + videoflip->configuring_method = videoflip->proposed_method; + } + videoflip->change_configuring_method = FALSE; + for (i = 0; i < gst_caps_get_size (ret); i++) { GstStructure *structure = gst_caps_get_structure (ret, i); gint par_n, par_d; @@ -142,7 +162,7 @@ if (gst_structure_get_int (structure, "width", &width) && gst_structure_get_int (structure, "height", &height)) { - switch (videoflip->active_method) { + switch (videoflip->configuring_method) { case GST_VIDEO_ORIENTATION_90R: case GST_VIDEO_ORIENTATION_90L: case GST_VIDEO_ORIENTATION_UL_LR: @@ -177,6 +197,7 @@ } } } + GST_OBJECT_UNLOCK (videoflip); GST_DEBUG_OBJECT (videoflip, "transformed %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT, caps, ret); @@ -435,7 +456,7 @@ } break; case GST_VIDEO_ORIENTATION_IDENTITY: - g_assert_not_reached (); + gst_video_frame_copy (dest, src); break; default: g_assert_not_reached (); @@ -634,7 +655,7 @@ } break; case GST_VIDEO_ORIENTATION_IDENTITY: - g_assert_not_reached (); + gst_video_frame_copy (dest, src); break; default: g_assert_not_reached (); @@ -735,7 +756,7 @@ } break; case GST_VIDEO_ORIENTATION_IDENTITY: - g_assert_not_reached (); + gst_video_frame_copy (dest, src); break; default: g_assert_not_reached (); @@ -951,7 +972,7 @@ } break; case GST_VIDEO_ORIENTATION_IDENTITY: - g_assert_not_reached (); + gst_video_frame_copy (dest, src); break; default: g_assert_not_reached (); @@ -959,13 +980,51 @@ } } +static void +gst_video_flip_configure_process (GstVideoFlip * vf) +{ + switch (vf->v_format) { + case GST_VIDEO_FORMAT_I420: + case GST_VIDEO_FORMAT_YV12: + case GST_VIDEO_FORMAT_Y444: + vf->process = gst_video_flip_planar_yuv; + break; + case GST_VIDEO_FORMAT_YUY2: + case GST_VIDEO_FORMAT_UYVY: + case GST_VIDEO_FORMAT_YVYU: + vf->process = gst_video_flip_y422; + break; + case GST_VIDEO_FORMAT_AYUV: + case GST_VIDEO_FORMAT_ARGB: + case GST_VIDEO_FORMAT_ABGR: + case GST_VIDEO_FORMAT_RGBA: + case GST_VIDEO_FORMAT_BGRA: + case GST_VIDEO_FORMAT_xRGB: + case GST_VIDEO_FORMAT_xBGR: + case GST_VIDEO_FORMAT_RGBx: + case GST_VIDEO_FORMAT_BGRx: + case GST_VIDEO_FORMAT_RGB: + case GST_VIDEO_FORMAT_BGR: + case GST_VIDEO_FORMAT_GRAY8: + case GST_VIDEO_FORMAT_GRAY16_BE: + case GST_VIDEO_FORMAT_GRAY16_LE: + vf->process = gst_video_flip_packed_simple; + break; + case GST_VIDEO_FORMAT_NV12: + case GST_VIDEO_FORMAT_NV21: + vf->process = gst_video_flip_semi_planar_yuv; + break; + default: + break; + } +} static gboolean gst_video_flip_set_info (GstVideoFilter * vfilter, GstCaps * incaps, GstVideoInfo * in_info, GstCaps * outcaps, GstVideoInfo * out_info) { GstVideoFlip *vf = GST_VIDEO_FLIP (vfilter); - gboolean ret = FALSE; + gboolean ret = FALSE, need_reconfigure = FALSE; vf->process = NULL; @@ -973,7 +1032,8 @@ goto invalid_caps; /* Check that they are correct */ - switch (vf->active_method) { + GST_OBJECT_LOCK (vf); + switch (vf->configuring_method) { case GST_VIDEO_ORIENTATION_90R: case GST_VIDEO_ORIENTATION_90L: case GST_VIDEO_ORIENTATION_UL_LR: @@ -987,8 +1047,6 @@ } break; case GST_VIDEO_ORIENTATION_IDENTITY: - - break; case GST_VIDEO_ORIENTATION_180: case GST_VIDEO_ORIENTATION_HORIZ: case GST_VIDEO_ORIENTATION_VERT: @@ -1007,42 +1065,32 @@ ret = TRUE; - switch (GST_VIDEO_INFO_FORMAT (in_info)) { - case GST_VIDEO_FORMAT_I420: - case GST_VIDEO_FORMAT_YV12: - case GST_VIDEO_FORMAT_Y444: - vf->process = gst_video_flip_planar_yuv; - break; - case GST_VIDEO_FORMAT_YUY2: - case GST_VIDEO_FORMAT_UYVY: - case GST_VIDEO_FORMAT_YVYU: - vf->process = gst_video_flip_y422; - break; - case GST_VIDEO_FORMAT_AYUV: - case GST_VIDEO_FORMAT_ARGB: - case GST_VIDEO_FORMAT_ABGR: - case GST_VIDEO_FORMAT_RGBA: - case GST_VIDEO_FORMAT_BGRA: - case GST_VIDEO_FORMAT_xRGB: - case GST_VIDEO_FORMAT_xBGR: - case GST_VIDEO_FORMAT_RGBx: - case GST_VIDEO_FORMAT_BGRx: - case GST_VIDEO_FORMAT_RGB: - case GST_VIDEO_FORMAT_BGR: - case GST_VIDEO_FORMAT_GRAY8: - case GST_VIDEO_FORMAT_GRAY16_BE: - case GST_VIDEO_FORMAT_GRAY16_LE: - vf->process = gst_video_flip_packed_simple; - break; - case GST_VIDEO_FORMAT_NV12: - case GST_VIDEO_FORMAT_NV21: - vf->process = gst_video_flip_semi_planar_yuv; - break; - default: - break; + { + GEnumValue *active_method_enum, *method_enum; + GEnumClass *enum_class = + g_type_class_ref (GST_TYPE_VIDEO_ORIENTATION_METHOD); + + active_method_enum = g_enum_get_value (enum_class, vf->active_method); + method_enum = g_enum_get_value (enum_class, vf->configuring_method); + GST_LOG_OBJECT (vf, "Changing active method from %s to configuring %s", + active_method_enum ? active_method_enum->value_nick : "(nil)", + method_enum ? method_enum->value_nick : "(nil)"); + g_type_class_unref (enum_class); } + vf->active_method = vf->configuring_method; + vf->change_configuring_method = TRUE; + if (vf->active_method != vf->proposed_method) + need_reconfigure = TRUE; + + vf->v_format = GST_VIDEO_INFO_FORMAT (in_info); + gst_video_flip_configure_process (vf); beach: + GST_OBJECT_UNLOCK (vf); + if (need_reconfigure) { + gst_base_transform_reconfigure_src (GST_BASE_TRANSFORM (vf)); + } + return ret && (vf->process != NULL); invalid_caps: @@ -1075,7 +1123,7 @@ else method = videoflip->method; - if (method != videoflip->active_method) { + if (method != videoflip->proposed_method) { GEnumValue *active_method_enum, *method_enum; GstBaseTransform *btrans = GST_BASE_TRANSFORM (videoflip); GEnumClass *enum_class = @@ -1084,12 +1132,12 @@ active_method_enum = g_enum_get_value (enum_class, videoflip->active_method); method_enum = g_enum_get_value (enum_class, method); - GST_DEBUG_OBJECT (videoflip, "Changing method from %s to %s", + GST_LOG_OBJECT (videoflip, "Changing method from %s to %s", active_method_enum ? active_method_enum->value_nick : "(nil)", method_enum ? method_enum->value_nick : "(nil)"); g_type_class_unref (enum_class); - videoflip->active_method = method; + videoflip->proposed_method = method; GST_OBJECT_UNLOCK (videoflip); @@ -1123,26 +1171,46 @@ GstVideoFrame * in_frame, GstVideoFrame * out_frame) { GEnumClass *enum_class; + GstVideoOrientationMethod active, proposed; GEnumValue *active_method_enum; GstVideoFlip *videoflip = GST_VIDEO_FLIP (vfilter); + GST_OBJECT_LOCK (videoflip); if (G_UNLIKELY (videoflip->process == NULL)) goto not_negotiated; + if (videoflip->configuring_method != videoflip->active_method) { + videoflip->active_method = videoflip->configuring_method; + gst_video_flip_configure_process (videoflip); + } + enum_class = g_type_class_ref (GST_TYPE_VIDEO_ORIENTATION_METHOD); active_method_enum = g_enum_get_value (enum_class, videoflip->active_method); - GST_LOG_OBJECT (videoflip, "videoflip: flipping (%s)", - active_method_enum ? active_method_enum->value_nick : "(nil)"); + GST_LOG_OBJECT (videoflip, + "videoflip: flipping (%s), input %ux%u output %ux%u", + active_method_enum ? active_method_enum->value_nick : "(nil)", + GST_VIDEO_FRAME_WIDTH (in_frame), GST_VIDEO_FRAME_HEIGHT (in_frame), + GST_VIDEO_FRAME_WIDTH (out_frame), GST_VIDEO_FRAME_HEIGHT (out_frame)); g_type_class_unref (enum_class); - GST_OBJECT_LOCK (videoflip); videoflip->process (videoflip, out_frame, in_frame); + + proposed = videoflip->proposed_method; + active = videoflip->active_method; + videoflip->change_configuring_method = TRUE; GST_OBJECT_UNLOCK (videoflip); + if (proposed != active) { + gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (videoflip), + proposed == GST_VIDEO_ORIENTATION_IDENTITY); + gst_base_transform_reconfigure_src (GST_BASE_TRANSFORM (videoflip)); + } + return GST_FLOW_OK; not_negotiated: { + GST_OBJECT_UNLOCK (videoflip); GST_ERROR_OBJECT (videoflip, "Not negotiated yet"); return GST_FLOW_NOT_NEGOTIATED; } @@ -1168,6 +1236,7 @@ if (gst_structure_get_double (structure, "pointer_x", &x) && gst_structure_get_double (structure, "pointer_y", &y)) { GST_DEBUG_OBJECT (vf, "converting %fx%f", x, y); + GST_OBJECT_LOCK (vf); switch (vf->active_method) { case GST_VIDEO_ORIENTATION_90R: new_x = y; @@ -1202,6 +1271,7 @@ new_y = y; break; } + GST_OBJECT_UNLOCK (vf); GST_DEBUG_OBJECT (vf, "to %fx%f", new_x, new_y); gst_structure_set (structure, "pointer_x", G_TYPE_DOUBLE, new_x, "pointer_y", G_TYPE_DOUBLE, new_y, NULL); @@ -1301,6 +1371,7 @@ GstElementClass *gstelement_class = (GstElementClass *) klass; GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass; GstVideoFilterClass *vfilter_class = (GstVideoFilterClass *) klass; + GParamSpec *pspec; GST_DEBUG_CATEGORY_INIT (video_flip_debug, "videoflip", 0, "videoflip"); @@ -1311,10 +1382,14 @@ g_param_spec_enum ("method", "method", "method (deprecated, use video-direction instead)", GST_TYPE_VIDEO_FLIP_METHOD, PROP_METHOD_DEFAULT, - GST_PARAM_CONTROLLABLE | G_PARAM_READWRITE | G_PARAM_CONSTRUCT | - G_PARAM_STATIC_STRINGS)); + GST_PARAM_CONTROLLABLE | GST_PARAM_MUTABLE_PLAYING | + G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_override_property (gobject_class, PROP_VIDEO_DIRECTION, "video-direction"); + /* override the overriden property's flags to include the mutable in playing + * flag */ + pspec = g_object_class_find_property (gobject_class, "video-direction"); + pspec->flags |= GST_PARAM_MUTABLE_PLAYING; gst_element_class_set_static_metadata (gstelement_class, "Video flipper", "Filter/Effect/Video", @@ -1345,4 +1420,6 @@ /* AUTO is not valid for active method, this is just to ensure we setup the * method in gst_video_flip_set_method() */ videoflip->active_method = GST_VIDEO_ORIENTATION_AUTO; + videoflip->proposed_method = GST_VIDEO_ORIENTATION_IDENTITY; + videoflip->configuring_method = GST_VIDEO_ORIENTATION_IDENTITY; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/gst/videofilter/gstvideoflip.h new/gst-plugins-good-1.18.3/gst/videofilter/gstvideoflip.h --- old/gst-plugins-good-1.18.2/gst/videofilter/gstvideoflip.h 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/gst/videofilter/gstvideoflip.h 2021-01-13 22:08:52.000000000 +0100 @@ -75,8 +75,13 @@ GstVideoFilter videofilter; /* < private > */ + GstVideoFormat v_format; + GstVideoOrientationMethod method; GstVideoOrientationMethod tag_method; + GstVideoOrientationMethod proposed_method; + gboolean change_configuring_method; + GstVideoOrientationMethod configuring_method; GstVideoOrientationMethod active_method; void (*process) (GstVideoFlip *videoflip, GstVideoFrame *dest, const GstVideoFrame *src); }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/gst-plugins-good.doap new/gst-plugins-good-1.18.3/gst-plugins-good.doap --- old/gst-plugins-good-1.18.2/gst-plugins-good.doap 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/gst-plugins-good.doap 2021-01-13 22:08:52.000000000 +0100 @@ -34,6 +34,16 @@ <release> <Version> + <revision>1.18.3</revision> + <branch>1.18</branch> + <name></name> + <created>2021-01-13</created> + <file-release rdf:resource="https://gstreamer.freedesktop.org/src/gst-plugins-good/gst-plugins-good-1.18.3.tar.xz" /> + </Version> + </release> + + <release> + <Version> <revision>1.18.2</revision> <branch>1.18</branch> <name></name> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/meson.build new/gst-plugins-good-1.18.3/meson.build --- old/gst-plugins-good-1.18.2/meson.build 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/meson.build 2021-01-13 22:08:52.000000000 +0100 @@ -1,5 +1,5 @@ project('gst-plugins-good', 'c', - version : '1.18.2', + version : '1.18.3', meson_version : '>= 0.48', default_options : [ 'warning_level=1', 'buildtype=debugoptimized' ]) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/sys/v4l2/gstv4l2object.c new/gst-plugins-good-1.18.3/sys/v4l2/gstv4l2object.c --- old/gst-plugins-good-1.18.2/sys/v4l2/gstv4l2object.c 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/sys/v4l2/gstv4l2object.c 2021-01-13 22:08:52.000000000 +0100 @@ -1329,7 +1329,7 @@ format = GST_VIDEO_FORMAT_ABGR; break; case V4L2_PIX_FMT_RGBA32: - format = GST_VIDEO_FORMAT_RGB; + format = GST_VIDEO_FORMAT_RGBA; break; case V4L2_PIX_FMT_ARGB32: format = GST_VIDEO_FORMAT_ARGB; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/tests/check/elements/splitmuxsink.c new/gst-plugins-good-1.18.3/tests/check/elements/splitmuxsink.c --- old/gst-plugins-good-1.18.2/tests/check/elements/splitmuxsink.c 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/tests/check/elements/splitmuxsink.c 2021-01-13 22:08:52.000000000 +0100 @@ -289,9 +289,18 @@ gst_object_unref (pipeline); } +struct splitmux_location_state +{ + GstElement *splitmuxsink; + gboolean got_format_location; + gboolean fragment_opened; + gchar *current_location; +}; + static gchar * check_format_location (GstElement * object, - guint fragment_id, GstSample * first_sample) + guint fragment_id, GstSample * first_sample, + struct splitmux_location_state *location_state) { GstBuffer *buf = gst_sample_get_buffer (first_sample); @@ -300,9 +309,54 @@ GST_LOG ("New file - first buffer %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf))); + if (location_state) { + fail_unless (location_state->got_format_location == FALSE, + "Got format-location signal twice without an intervening splitmuxsink-fragment-closed"); + location_state->got_format_location = TRUE; + } + return NULL; } +static GstBusSyncReply +bus_sync_handler (GstBus * bus, GstMessage * message, + struct splitmux_location_state *location_state) +{ + switch (message->type) { + case GST_MESSAGE_ELEMENT: + { + const GstStructure *s = gst_message_get_structure (message); + if (message->src == GST_OBJECT_CAST (location_state->splitmuxsink)) { + if (gst_structure_has_name (s, "splitmuxsink-fragment-opened")) { + const gchar *location = gst_structure_get_string (s, "location"); + fail_unless (location != NULL); + fail_unless (location_state->got_format_location == TRUE, + "Failed to get format-location before fragment start"); + fail_unless (location_state->fragment_opened == FALSE); + location_state->fragment_opened = TRUE; + + /* The location must be different to last time */ + fail_unless (location_state->current_location == NULL + || !g_str_equal (location_state->current_location, location)); + g_free (location_state->current_location); + location_state->current_location = g_strdup (location); + + } else if (gst_structure_has_name (s, "splitmuxsink-fragment-closed")) { + fail_unless (location_state->got_format_location == TRUE); + fail_unless (location_state->fragment_opened == TRUE); + location_state->got_format_location = FALSE; /* We need another format-location before the next open */ + location_state->fragment_opened = FALSE; + } + } + break; + } + default: + break; + } + + return GST_BUS_PASS; +} + GST_START_TEST (test_splitmuxsink) { GstMessage *msg; @@ -313,6 +367,8 @@ gchar *dest_pattern; guint count; gchar *in_pattern; + struct splitmux_location_state location_state = { NULL, FALSE, FALSE, NULL }; + GstBus *bus; /* This pipeline has a small time cutoff - it should start a new file * every GOP, ie 1 second */ @@ -322,17 +378,27 @@ " queue ! theoraenc keyframe-force=5 ! splitmuxsink name=splitsink " " max-size-time=1000000 max-size-bytes=1000000 muxer=oggmux", NULL); fail_if (pipeline == NULL); - sink = gst_bin_get_by_name (GST_BIN (pipeline), "splitsink"); + location_state.splitmuxsink = sink = + gst_bin_get_by_name (GST_BIN (pipeline), "splitsink"); fail_if (sink == NULL); g_signal_connect (sink, "format-location-full", - (GCallback) check_format_location, NULL); + (GCallback) check_format_location, &location_state); + dest_pattern = g_build_filename (tmpdir, "out%05d.ogg", NULL); g_object_set (G_OBJECT (sink), "location", dest_pattern, NULL); g_free (dest_pattern); g_object_unref (sink); + bus = gst_element_get_bus (pipeline); + gst_bus_set_sync_handler (bus, (GstBusSyncHandler) bus_sync_handler, + &location_state, NULL); + gst_object_unref (bus); + msg = run_pipeline (pipeline); + /* Clean up the location state */ + g_free (location_state.current_location); + if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR) dump_error (msg); fail_unless (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_EOS); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/tests/check/elements/videoflip.c new/gst-plugins-good-1.18.3/tests/check/elements/videoflip.c --- old/gst-plugins-good-1.18.2/tests/check/elements/videoflip.c 1970-01-01 01:00:00.000000000 +0100 +++ new/gst-plugins-good-1.18.3/tests/check/elements/videoflip.c 2021-01-13 22:08:52.000000000 +0100 @@ -0,0 +1,286 @@ +/* GStreamer + * + * unit test for videofilter elements + * + * Copyright (C) <2006> Mark Nauwelaerts <man...@skynet.be> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#include <stdarg.h> + +#include <gst/video/video.h> +#include <gst/check/gstcheck.h> +#include <gst/check/gstharness.h> + +static GstBuffer * +create_test_video_buffer_rgba8 (GstVideoInfo * info) +{ + guint8 *data; + guint i = 0, j, k; + gsize stride = GST_VIDEO_INFO_PLANE_STRIDE (info, i); + + data = g_malloc0 (info->size); + + for (j = 0; j < GST_VIDEO_INFO_COMP_HEIGHT (info, i); j++) { + for (k = 0; k < GST_VIDEO_INFO_COMP_WIDTH (info, i); k++) { + data[(j * stride + 4 * k) + 0] = j % 255; + data[(j * stride + 4 * k) + 1] = k % 255; + data[(j * stride + 4 * k) + 2] = (j + k) % 255; + data[(j * stride + 4 * k) + 3] = 255; + } + } + + return gst_buffer_new_wrapped (data, info->size); +} + +GST_START_TEST (test_passthrough) +{ + GstHarness *flip = gst_harness_new ("videoflip"); + GstVideoInfo in_info, out_info; + GstCaps *in_caps, *out_caps; + GstEvent *e; + GstBuffer *buf; + + gst_video_info_set_format (&in_info, GST_VIDEO_FORMAT_RGBA, 4, 9); + in_caps = gst_video_info_to_caps (&in_info); + + gst_harness_set_src_caps (flip, in_caps); + + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_STREAM_START); + gst_event_unref (e); + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_CAPS); + gst_event_parse_caps (e, &out_caps); + fail_unless (gst_video_info_from_caps (&out_info, out_caps)); + fail_unless_equals_int (GST_VIDEO_INFO_WIDTH (&in_info), + GST_VIDEO_INFO_WIDTH (&out_info)); + fail_unless_equals_int (GST_VIDEO_INFO_HEIGHT (&in_info), + GST_VIDEO_INFO_HEIGHT (&out_info)); + gst_event_unref (e); + + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_SEGMENT); + gst_event_unref (e); + + buf = create_test_video_buffer_rgba8 (&in_info); + buf = gst_harness_push_and_pull (flip, buf); + fail_unless (buf != NULL); + gst_buffer_unref (buf); + + gst_harness_teardown (flip); +} + +GST_END_TEST; + +GST_START_TEST (test_change_method) +{ + GstHarness *flip = gst_harness_new ("videoflip"); + GstVideoInfo in_info, out_info; + GstCaps *in_caps, *out_caps; + GstEvent *e; + GstBuffer *buf; + + gst_video_info_set_format (&in_info, GST_VIDEO_FORMAT_RGBA, 4, 9); + in_caps = gst_video_info_to_caps (&in_info); + + gst_harness_set_src_caps (flip, in_caps); + + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_STREAM_START); + gst_event_unref (e); + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_CAPS); + gst_event_parse_caps (e, &out_caps); + fail_unless (gst_video_info_from_caps (&out_info, out_caps)); + fail_unless_equals_int (GST_VIDEO_INFO_WIDTH (&in_info), + GST_VIDEO_INFO_WIDTH (&out_info)); + fail_unless_equals_int (GST_VIDEO_INFO_HEIGHT (&in_info), + GST_VIDEO_INFO_HEIGHT (&out_info)); + gst_event_unref (e); + + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_SEGMENT); + gst_event_unref (e); + + buf = create_test_video_buffer_rgba8 (&in_info); + buf = gst_harness_push_and_pull (flip, buf); + fail_unless (buf != NULL); + gst_buffer_unref (buf); + + g_object_set (flip->element, "video-direction", 1 /* 90r */ , NULL); + + buf = create_test_video_buffer_rgba8 (&in_info); + fail_unless_equals_int (gst_harness_push (flip, buf), GST_FLOW_OK); + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_CAPS); + gst_event_parse_caps (e, &out_caps); + fail_unless (gst_video_info_from_caps (&out_info, out_caps)); + fail_unless_equals_int (GST_VIDEO_INFO_WIDTH (&in_info), + GST_VIDEO_INFO_HEIGHT (&out_info)); + fail_unless_equals_int (GST_VIDEO_INFO_HEIGHT (&in_info), + GST_VIDEO_INFO_WIDTH (&out_info)); + gst_event_unref (e); + buf = gst_harness_pull (flip); + fail_unless (buf != NULL); + gst_buffer_unref (buf); + + gst_harness_teardown (flip); +} + +GST_END_TEST; + +GST_START_TEST (test_change_method_twice_same_caps_different_method) +{ + GstHarness *flip = gst_harness_new ("videoflip"); + GstVideoInfo in_info, out_info; + GstCaps *in_caps, *out_caps; + GstEvent *e; + GstBuffer *input, *output, *buf; + GstMapInfo in_map_info, out_map_info; + + gst_video_info_set_format (&in_info, GST_VIDEO_FORMAT_RGBA, 4, 9); + in_caps = gst_video_info_to_caps (&in_info); + + gst_harness_set_src_caps (flip, in_caps); + + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_STREAM_START); + gst_event_unref (e); + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_CAPS); + gst_event_parse_caps (e, &out_caps); + fail_unless (gst_video_info_from_caps (&out_info, out_caps)); + fail_unless_equals_int (GST_VIDEO_INFO_WIDTH (&in_info), + GST_VIDEO_INFO_WIDTH (&out_info)); + fail_unless_equals_int (GST_VIDEO_INFO_HEIGHT (&in_info), + GST_VIDEO_INFO_HEIGHT (&out_info)); + gst_event_unref (e); + + e = gst_harness_pull_event (flip); + fail_unless_equals_int (GST_EVENT_TYPE (e), GST_EVENT_SEGMENT); + gst_event_unref (e); + + buf = create_test_video_buffer_rgba8 (&in_info); + buf = gst_harness_push_and_pull (flip, buf); + fail_unless (buf != NULL); + gst_buffer_unref (buf); + + g_object_set (flip->element, "video-direction", 1 /* 90r */ , NULL); + g_object_set (flip->element, "video-direction", 2 /* 180 */ , NULL); + + input = create_test_video_buffer_rgba8 (&in_info); + fail_unless_equals_int (gst_harness_push (flip, gst_buffer_ref (input)), + GST_FLOW_OK); + /* caps will not change and basetransform won't send updated ones so we + * can't check for them */ + output = gst_harness_pull (flip); + fail_unless (output != NULL); + + fail_unless (gst_buffer_map (input, &in_map_info, GST_MAP_READ)); + fail_unless (gst_buffer_map (output, &out_map_info, GST_MAP_READ)); + + { + gsize top_right = (GST_VIDEO_INFO_WIDTH (&in_info) - 1) * 4; + gsize bottom_left = + (GST_VIDEO_INFO_HEIGHT (&out_info) - + 1) * GST_VIDEO_INFO_PLANE_STRIDE (&out_info, 0); + + fail_unless_equals_int (in_map_info.data[top_right + 0], + out_map_info.data[bottom_left + 0]); + fail_unless_equals_int (in_map_info.data[top_right + 1], + out_map_info.data[bottom_left + 1]); + fail_unless_equals_int (in_map_info.data[top_right + 2], + out_map_info.data[bottom_left + 2]); + fail_unless_equals_int (in_map_info.data[top_right + 3], + out_map_info.data[bottom_left + 3]); + } + + gst_buffer_unmap (input, &in_map_info); + gst_buffer_unmap (output, &out_map_info); + + gst_buffer_unref (input); + gst_buffer_unref (output); + + gst_harness_teardown (flip); +} + +GST_END_TEST; +GST_START_TEST (test_stress_change_method) +{ + GstHarness *flip = gst_harness_new ("videoflip"); + GParamSpec *pspec = + g_object_class_find_property (G_OBJECT_GET_CLASS (flip->element), + "video-direction"); + GstHarnessThread *thread_identity, *thread_90r; + GValue direction_identity = G_VALUE_INIT, direction_90r = G_VALUE_INIT; + GstVideoInfo in_info; + guint i = 0; +#define N_PUSHES 1000 + + gst_video_info_set_format (&in_info, GST_VIDEO_FORMAT_RGBA, 4, 9); + gst_harness_set_src_caps (flip, gst_video_info_to_caps (&in_info)); + + g_value_init (&direction_identity, pspec->value_type); + g_value_init (&direction_90r, pspec->value_type); + + fail_unless (gst_value_deserialize (&direction_identity, "identity")); + fail_unless (gst_value_deserialize (&direction_90r, "90r")); + + thread_identity = + gst_harness_stress_property_start_full (flip, "video-direction", + &direction_identity, 210); + thread_90r = + gst_harness_stress_property_start_full (flip, "video-direction", + &direction_90r, 160); + + while (i++ < N_PUSHES) { + GstBuffer *buf = create_test_video_buffer_rgba8 (&in_info); + buf = gst_harness_push_and_pull (flip, buf); + fail_unless (buf != NULL); + gst_buffer_unref (buf); + g_usleep (100); + } + + gst_harness_stress_thread_stop (thread_identity); + gst_harness_stress_thread_stop (thread_90r); + + g_value_unset (&direction_identity); + g_value_unset (&direction_90r); + + gst_harness_teardown (flip); +} + +GST_END_TEST; + +static Suite * +videoflip_suite (void) +{ + Suite *s = suite_create ("videoflip"); + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + tcase_add_test (tc_chain, test_passthrough); + tcase_add_test (tc_chain, test_change_method); + tcase_add_test (tc_chain, + test_change_method_twice_same_caps_different_method); + tcase_add_test (tc_chain, test_stress_change_method); + + return s; +} + +GST_CHECK_MAIN (videoflip); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gst-plugins-good-1.18.2/tests/check/meson.build new/gst-plugins-good-1.18.3/tests/check/meson.build --- old/gst-plugins-good-1.18.2/tests/check/meson.build 2020-12-06 14:22:59.000000000 +0100 +++ new/gst-plugins-good-1.18.3/tests/check/meson.build 2021-01-13 22:08:52.000000000 +0100 @@ -95,6 +95,7 @@ [ 'elements/videobox' ], [ 'elements/videocrop' ], [ 'elements/videofilter' ], + [ 'elements/videoflip' ], [ 'elements/videomixer' ], [ 'elements/aspectratiocrop' ], [ 'pipelines/wavenc' ],