Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package gstreamer for openSUSE:Factory checked in at 2026-08-06 16:19:11 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/gstreamer (Old) and /work/SRC/openSUSE:Factory/.gstreamer.new.16738 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "gstreamer" Thu Aug 6 16:19:11 2026 rev:125 rq:1369817 version:1.28.6 Changes: -------- --- /work/SRC/openSUSE:Factory/gstreamer/gstreamer.changes 2026-07-12 16:21:07.543938060 +0200 +++ /work/SRC/openSUSE:Factory/.gstreamer.new.16738/gstreamer.changes 2026-08-06 16:19:27.390698353 +0200 @@ -1,0 +2,46 @@ +Wed Aug 5 15:41:47 UTC 2026 - Bjørn Lie <[email protected]> + +- Update to version 1.28.6: + + Highlighted bugfixes in 1.28.6 + - Various security fixes and playback fixes + - playbin3, playbin: fix stalls after re-enabling previously + disabled subtitles + - Fix regression in core if a pad is re-linked while changed + sticky events are being pushed + - dtls/webrtc: fix some issues with OpenSSL 4.0.0 + - RTP retransmission bitrate estimation fixes + - Fix RTP depayloading of SMPTE ST291 frames with multiple ANC + packets + - Add H.266 muxing support to the Rust (f)mp4 muxers + - Better handling of input buffers without timestamps in Rust + (f)mp4 muxers + - webrtcsink H.264 level/profile negotiation fixes and support + for nvv4l2h265enc encoder + - SMPTE ST2038 ancillary metadata and closed caption combiner + improvements + - Fix SEI insertion into H.265/HEVC streams with alpha + - Windows D3D11 WinRT screen capture element fixes + - Improved coded buffer size handling for VA encoders + - Textaccumulate: various tweaks how the element outputs text, + plus better handling of French punctuation + - hlssink3: improved handling of input buffers without + timestamps + - Fix build against FFmpeg 9.0 + - cerbero: fix Windows packages binary size increase + regression; upgrade libsrt recipe to 1.5.6 + - Various bug fixes, build fixes, memory leak fixes, and other + stability and reliability improvements + + gstreamer: + - baseparse: Don't reset infer_ts/pts_interpolate subclass + configuration in reset() and related fixes + - cpuid: fix AArch64 NEON detection to check HWCAP_ASIMD, not + HWCAP_NEON + - pad: fix livelock when pushing changed sticky events when the + pad is re-linked + - valve: Don't send a reconfigure even when setting the drop + property to the same value + - meson: Make the g-ir-scanner init section consistent across + modules + - meson: use dependency('dl') instead of cc.find_library('dl') + +------------------------------------------------------------------- Old: ---- gstreamer-1.28.5.obscpio New: ---- gstreamer-1.28.6.obscpio ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ gstreamer.spec ++++++ --- /var/tmp/diff_new_pack.JSePt1/_old 2026-08-06 16:19:31.010824651 +0200 +++ /var/tmp/diff_new_pack.JSePt1/_new 2026-08-06 16:19:31.038825627 +0200 @@ -19,7 +19,7 @@ %define gst_branch 1.0 Name: gstreamer -Version: 1.28.5 +Version: 1.28.6 Release: 0 Summary: Streaming-Media Framework Runtime License: LGPL-2.1-or-later ++++++ _service ++++++ --- /var/tmp/diff_new_pack.JSePt1/_old 2026-08-06 16:19:31.350836513 +0200 +++ /var/tmp/diff_new_pack.JSePt1/_new 2026-08-06 16:19:31.378837490 +0200 @@ -5,7 +5,7 @@ <param name="url">https://gitlab.freedesktop.org/gstreamer/gstreamer.git</param> <param name="subdir">subprojects/gstreamer</param> <param name="filename">gstreamer</param> - <param name="revision">1.28.5</param> + <param name="revision">1.28.6</param> <param name="versionformat">@PARENT_TAG@+@TAG_OFFSET@</param> <param name="versionrewrite-pattern">v?(.*)\+0</param> <param name="versionrewrite-replacement">\1</param> ++++++ gstreamer-1.28.5.obscpio -> gstreamer-1.28.6.obscpio ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gstreamer-1.28.5/gst/gstcpuid.c new/gstreamer-1.28.6/gst/gstcpuid.c --- old/gstreamer-1.28.5/gst/gstcpuid.c 2026-07-08 23:42:39.000000000 +0200 +++ new/gstreamer-1.28.6/gst/gstcpuid.c 2026-08-05 13:59:39.000000000 +0200 @@ -40,10 +40,16 @@ #if defined(__linux__) && defined(__ARM_ARCH) #include <asm/hwcap.h> #include <sys/auxv.h> +#if defined(__aarch64__) +#ifndef HWCAP_ASIMD +#define HWCAP_ASIMD (1 << 1) +#endif +#else #ifndef HWCAP_NEON // Some Android NDKs lack it. #define HWCAP_NEON (1 << 12) #endif #endif +#endif #ifdef _MSC_VER // Contains the definition of __cpuidex @@ -155,7 +161,11 @@ // If Linux, rely on getauxval; otherwise search Arm macros // https://developer.arm.com/documentation/dui0774/b/other-compiler-specific-features/predefined-macros #if defined(__linux__) && (!defined(__ANDROID_API__) || __ANDROID_API__ >= 18) +#if defined(__aarch64__) + cpuid.neon = (getauxval (AT_HWCAP) & HWCAP_ASIMD) != 0 ? TRUE : FALSE; +#else cpuid.neon = (getauxval (AT_HWCAP) & HWCAP_NEON) != 0 ? TRUE : FALSE; +#endif #elif defined(__ARM_NEON) || defined(__aarch64__) cpuid.neon = TRUE; #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gstreamer-1.28.5/gst/gstpad.c new/gstreamer-1.28.6/gst/gstpad.c --- old/gstreamer-1.28.5/gst/gstpad.c 2026-07-08 23:42:39.000000000 +0200 +++ new/gstreamer-1.28.6/gst/gstpad.c 2026-08-05 13:59:39.000000000 +0200 @@ -5643,15 +5643,18 @@ static void push_changed_sticky_events_before (GstPad * pad, GstEvent * event) { - PushStickyData data = { GST_FLOW_OK, FALSE, event, pad->priv->peer_cookie }; - GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_PENDING_EVENTS); - /* Push all sticky events before our current one - * that have changed */ + * that have changed, looping and trying again if interrupted */ do { + PushStickyData data = { GST_FLOW_OK, FALSE, event, pad->priv->peer_cookie }; + GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_PENDING_EVENTS); + events_foreach (pad, sticky_changed, &data); - } while (data.ret == GST_FLOW_PROBE_INTERRUPTED - && GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_PENDING_EVENTS)); + + if (data.ret != GST_FLOW_PROBE_INTERRUPTED) { + break; + } + } while (TRUE); } /* should be called with pad LOCK */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gstreamer-1.28.5/gstreamer.doap new/gstreamer-1.28.6/gstreamer.doap --- old/gstreamer-1.28.5/gstreamer.doap 2026-07-08 23:42:39.000000000 +0200 +++ new/gstreamer-1.28.6/gstreamer.doap 2026-08-05 13:59:39.000000000 +0200 @@ -40,6 +40,16 @@ <release> <Version> + <revision>1.28.6</revision> + <branch>1.28</branch> + <name></name> + <created>2026-08-05</created> + <file-release rdf:resource="https://gstreamer.freedesktop.org/src/gstreamer/gstreamer-1.28.6.tar.xz"; /> + </Version> + </release> + + <release> + <Version> <revision>1.28.5</revision> <branch>1.28</branch> <name></name> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gstreamer-1.28.5/libs/gst/base/gstbaseparse.c new/gstreamer-1.28.6/libs/gst/base/gstbaseparse.c --- old/gstreamer-1.28.5/libs/gst/base/gstbaseparse.c 2026-07-08 23:42:39.000000000 +0200 +++ new/gstreamer-1.28.6/libs/gst/base/gstbaseparse.c 2026-08-05 13:59:39.000000000 +0200 @@ -673,6 +673,11 @@ /* init state */ gst_base_parse_reset (parse); + + /* default parser configuration. subclasses override this in their _init() */ + parse->priv->pts_interpolate = TRUE; + parse->priv->infer_ts = TRUE; + GST_DEBUG_OBJECT (parse, "init ok"); GST_OBJECT_FLAG_SET (parse, GST_ELEMENT_FLAG_INDEXABLE); @@ -889,8 +894,6 @@ parse->priv->next_dts = 0; parse->priv->syncable = TRUE; parse->priv->passthrough = FALSE; - parse->priv->pts_interpolate = TRUE; - parse->priv->infer_ts = TRUE; parse->priv->has_timing_info = FALSE; parse->priv->min_bitrate = G_MAXUINT; parse->priv->max_bitrate = 0; @@ -3941,6 +3944,9 @@ * duration. Alternatively, if @interval is non-zero (default), then stream * duration is determined based on estimated bitrate, and updated every @interval * frames. + * + * This value is reset during PAUSED->READY state changes. Subclasses must + * call this function from #GstBaseParseClass::start if they want to set a static value. */ void gst_base_parse_set_duration (GstBaseParse * parse, @@ -3992,6 +3998,9 @@ * is used to estimate the total duration of the stream and to estimate * a seek position, if there's no index and the format is syncable * (see gst_base_parse_set_syncable()). + * + * This value is reset during PAUSED->READY state changes. Subclasses must + * call this function from #GstBaseParseClass::start if they want to set a static value. */ void gst_base_parse_set_average_bitrate (GstBaseParse * parse, guint bitrate) @@ -4008,6 +4017,9 @@ * * Subclass can use this function to tell the base class that it needs to * be given buffers of at least @min_size bytes. + * + * This value is reset during PAUSED->READY state changes. Subclasses must + * call this function from #GstBaseParseClass::start if they want to set a static value. */ void gst_base_parse_set_min_frame_size (GstBaseParse * parse, guint min_size) @@ -4031,6 +4043,9 @@ * location, a corresponding decoder might need an initial @lead_in and a * following @lead_out number of frames to ensure the desired segment is * entirely filled upon decoding. + * + * This value is reset during PAUSED->READY state changes. Subclasses must + * call this function from #GstBaseParseClass::start if they want to set a static value. */ void gst_base_parse_set_frame_rate (GstBaseParse * parse, guint fps_num, @@ -4083,6 +4098,9 @@ * Set if frames carry timing information which the subclass can (generally) * parse and provide. In particular, intrinsic (rather than estimated) time * can be obtained following a seek. + * + * This value is reset during PAUSED->READY state changes. Subclasses must + * call this function from #GstBaseParseClass::start if they want to set a static value. */ void gst_base_parse_set_has_timing_info (GstBaseParse * parse, gboolean has_timing) @@ -4099,6 +4117,9 @@ * Set if frame starts can be identified. This is set by default and * determines whether seeking based on bitrate averages * is possible for a format/stream. + * + * This value is reset during PAUSED->READY state changes. Subclasses must + * call this function from #GstBaseParseClass::start if they want to set a static value. */ void gst_base_parse_set_syncable (GstBaseParse * parse, gboolean syncable) @@ -4119,6 +4140,9 @@ * will be invoked, but #GstBaseParseClass::pre_push_frame will still be * invoked, so subclass can perform as much or as little is appropriate for * passthrough semantics in #GstBaseParseClass::pre_push_frame. + * + * This value is reset during PAUSED->READY state changes. Subclasses must + * call this function from #GstBaseParseClass::start if they want to set a static value. */ void gst_base_parse_set_passthrough (GstBaseParse * parse, gboolean passthrough) @@ -4136,6 +4160,9 @@ * interpolation (previous timestamp + duration), which is incorrect for * data streams with reordering, where PTS can go backward. Sub-classes * implementing such formats should disable PTS interpolation. + * + * This value is retained over PAUSED->READY state changes. Subclasses + * can call this function from their instance init function. */ void gst_base_parse_set_pts_interpolation (GstBaseParse * parse, @@ -4155,6 +4182,9 @@ * versa. While this is generally correct for audio data, it may not * be otherwise. Sub-classes implementing such formats should disable * timestamp inferring. + * + * This value is retained over PAUSED->READY state changes. Subclasses + * can call this function from their instance init function. */ void gst_base_parse_set_infer_ts (GstBaseParse * parse, gboolean infer_ts) @@ -4176,6 +4206,9 @@ * If the provided values changed from previously provided ones, this will * also post a LATENCY message on the bus so the pipeline can reconfigure its * global latency. + * + * This value is retained over PAUSED->READY state changes. Subclasses + * can call this function from their instance init function. */ void gst_base_parse_set_latency (GstBaseParse * parse, GstClockTime min_latency, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gstreamer-1.28.5/meson.build new/gstreamer-1.28.6/meson.build --- old/gstreamer-1.28.5/meson.build 2026-07-08 23:42:39.000000000 +0200 +++ new/gstreamer-1.28.6/meson.build 2026-08-05 13:59:39.000000000 +0200 @@ -1,5 +1,5 @@ project('gstreamer', 'c', - version : '1.28.5', + version : '1.28.6', meson_version : '>= 1.4', default_options : [ 'warning_level=1', 'buildtype=debugoptimized', @@ -550,7 +550,7 @@ test_deps = [gmp_dep, gsl_dep, gslcblas_dep] # Used by gstinfo.c -dl_dep = cc.find_library('dl', required : false) +dl_dep = dependency('dl', required : false) cdata.set('HAVE_DLADDR', cc.has_function('dladdr', dependencies : dl_dep)) cdata.set('GST_ENABLE_EXTRA_CHECKS', not get_option('extra-checks').disabled()) cdata.set('USE_POISONING', get_option('poisoning')) @@ -611,7 +611,7 @@ gir_init_section = [ '--add-init-section=extern void gst_init(gint*,gchar**);' + \ 'g_setenv("GST_REGISTRY_DISABLE", "yes", TRUE);' + \ - 'g_setenv("GST_REGISTRY_1.0", "/no/way/this/exists.reg", TRUE);' + \ + 'g_setenv("GST_REGISTRY_1_0", "@0@", TRUE);'.format(meson.current_build_dir() + '/gir_empty_registry.reg') + \ 'g_setenv("GST_PLUGIN_PATH_1_0", "", TRUE);' + \ 'g_setenv("GST_PLUGIN_SYSTEM_PATH_1_0", "", TRUE);' + \ 'g_setenv("GST_TRACERS", "", TRUE);' + \ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gstreamer-1.28.5/plugins/elements/gstvalve.c new/gstreamer-1.28.6/plugins/elements/gstvalve.c --- old/gstreamer-1.28.5/plugins/elements/gstvalve.c 2026-07-08 23:42:39.000000000 +0200 +++ new/gstreamer-1.28.6/plugins/elements/gstvalve.c 2026-08-05 13:59:39.000000000 +0200 @@ -178,10 +178,13 @@ GstValve *valve = GST_VALVE (object); switch (prop_id) { - case PROP_DROP: - g_atomic_int_set (&valve->drop, g_value_get_boolean (value)); - gst_pad_push_event (valve->sinkpad, gst_event_new_reconfigure ()); + case PROP_DROP:{ + gboolean drop = g_value_get_boolean (value); + if (g_atomic_int_compare_and_exchange (&valve->drop, !drop, drop)) { + gst_pad_push_event (valve->sinkpad, gst_event_new_reconfigure ()); + } break; + } case PROP_DROP_MODE: valve->drop_mode = g_value_get_enum (value); break; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/gstreamer-1.28.5/tests/check/gst/gstpad.c new/gstreamer-1.28.6/tests/check/gst/gstpad.c --- old/gstreamer-1.28.5/tests/check/gst/gstpad.c 2026-07-08 23:42:39.000000000 +0200 +++ new/gstreamer-1.28.6/tests/check/gst/gstpad.c 2026-08-05 13:59:39.000000000 +0200 @@ -2692,6 +2692,126 @@ GST_END_TEST; +typedef struct +{ + GstPad *srcpad; + GstPad *sinkpad; + gint caps_drops; + gboolean relinked; + gint push_done; +} StickyRelinkData; + +static GstPadProbeReturn +sticky_relink_drop_caps_probe (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + StickyRelinkData *data = user_data; + GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info); + + if (GST_EVENT_TYPE (event) != GST_EVENT_CAPS) + return GST_PAD_PROBE_OK; + + /* the first caps push comes from the caps push in the test body, the + * second from the trigger push's own sticky check and the third from + * inside push_changed_sticky_events_before(). Re-linking there changes + * the peer cookie after that loop captured it */ + if (g_atomic_int_add (&data->caps_drops, 1) + 1 == 3) { + gst_pad_unlink (pad, data->sinkpad); + fail_unless (gst_pad_link_full (pad, data->sinkpad, + GST_PAD_LINK_CHECK_NOTHING) == GST_PAD_LINK_OK); + data->relinked = TRUE; + } + + return GST_PAD_PROBE_DROP; +} + +static gboolean +sticky_relink_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) +{ + gst_event_unref (event); + return TRUE; +} + +static gpointer +sticky_relink_push_trigger (gpointer user_data) +{ + StickyRelinkData *data = user_data; + + gst_pad_push_event (data->srcpad, + gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, + gst_structure_new_empty ("test/serialized-trigger"))); + g_atomic_int_set (&data->push_done, 1); + + return NULL; +} + +/* Test that re-linking a pad while its sticky events are being re-sent + * does not livelock the re-push loop in + * push_changed_sticky_events_before() */ +GST_START_TEST (test_sticky_events_relink_during_repush) +{ + GstCaps *caps; + StickyRelinkData data = { NULL, }; + GThread *thread; + gint64 deadline; + + data.srcpad = gst_pad_new ("src", GST_PAD_SRC); + fail_unless (data.srcpad != NULL); + data.sinkpad = gst_pad_new ("sink", GST_PAD_SINK); + fail_unless (data.sinkpad != NULL); + gst_pad_set_event_function (data.sinkpad, sticky_relink_sink_event); + gst_pad_set_active (data.srcpad, TRUE); + gst_pad_set_active (data.sinkpad, TRUE); + fail_unless (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (data.srcpad, + data.sinkpad))); + + /* push the initial sticky events, all received downstream */ + fail_unless (gst_pad_push_event (data.srcpad, + gst_event_new_stream_start ("test"))); + caps = gst_caps_new_simple ("foo/bar", "rate", G_TYPE_INT, 44100, NULL); + fail_unless (gst_pad_push_event (data.srcpad, gst_event_new_caps (caps))); + gst_caps_unref (caps); + fail_unless (gst_pad_push_event (data.srcpad, + gst_event_new_segment (&dummy_segment))); + + gst_pad_add_probe (data.srcpad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, + sticky_relink_drop_caps_probe, &data, NULL); + + /* new caps, dropped by the probe. The pad now has a pending sticky + * event */ + caps = gst_caps_new_simple ("foo/bar", "rate", G_TYPE_INT, 48000, NULL); + fail_unless (gst_pad_push_event (data.srcpad, gst_event_new_caps (caps))); + gst_caps_unref (caps); + + /* pushing any serialized event now re-sends the pending caps and the + * probe re-links the pad during the re-send. The push must return */ + thread = + g_thread_new ("sticky-relink-push", sticky_relink_push_trigger, &data); + + deadline = g_get_monotonic_time () + 10 * G_USEC_PER_SEC; + while (!g_atomic_int_get (&data.push_done)) { + fail_unless (g_get_monotonic_time () < deadline, + "sticky event re-push livelocked after a mid-push re-link " + "(%d caps drops)", g_atomic_int_get (&data.caps_drops)); + g_usleep (G_USEC_PER_SEC / 100); + } + + g_thread_join (thread); + + /* guard against the scenario silently not being exercised anymore if + * the sticky pushing code paths change */ + fail_unless (data.relinked); + fail_unless (g_atomic_int_get (&data.caps_drops) >= 4, + "the pending caps was never re-pushed after the re-link"); + + gst_pad_set_active (data.srcpad, FALSE); + gst_pad_set_active (data.sinkpad, FALSE); + gst_object_unref (data.srcpad); + gst_object_unref (data.sinkpad); +} + +GST_END_TEST; + static GstFlowReturn next_return; static GstFlowReturn @@ -3523,6 +3643,7 @@ tcase_add_test (tc_chain, test_block_async_full_destroy_dispose); tcase_add_test (tc_chain, test_block_async_replace_callback_no_flush); tcase_add_test (tc_chain, test_sticky_events); + tcase_add_test (tc_chain, test_sticky_events_relink_during_repush); tcase_add_test (tc_chain, test_last_flow_return_push); tcase_add_test (tc_chain, test_last_flow_return_pull); tcase_add_test (tc_chain, test_flush_stop_inactive); ++++++ gstreamer.obsinfo ++++++ --- /var/tmp/diff_new_pack.JSePt1/_old 2026-08-06 16:19:33.698918432 +0200 +++ /var/tmp/diff_new_pack.JSePt1/_new 2026-08-06 16:19:33.706918711 +0200 @@ -1,5 +1,5 @@ name: gstreamer -version: 1.28.5 -mtime: 1783546959 -commit: 727ceb91886862d200f423baf36cde2bb7ce5b4d +version: 1.28.6 +mtime: 1785931179 +commit: 2d3e05cbdad68e47d645f548899b432dc9fb4473
