Packman Build Service PMBS

gstreamer-plugins-bad-codecs.changes Changed

gstreamer-plugins-bad-codecs.spec Changed

build_what_we_need_only.patch Changed

@@ -1,8 +1,8 @@
-Index: gst-plugins-bad-1.28.0/meson.build
+Index: gst-plugins-bad-1.28.5/meson.build
 ===================================================================
---- gst-plugins-bad-1.28.0.orig/meson.build
-+++ gst-plugins-bad-1.28.0/meson.build
-@@ -315,6 +315,8 @@ gstapp_dep = dependency('gstreamer-app-1
+--- gst-plugins-bad-1.28.5.orig/meson.build
++++ gst-plugins-bad-1.28.5/meson.build
+@@ -321,6 +321,8 @@ gstapp_dep = dependency('gstreamer-app-1
      fallback : 'gst-plugins-base', 'app_dep')
  gstaudio_dep = dependency('gstreamer-audio-1.0', version : gst_req,
      fallback : 'gst-plugins-base', 'audio_dep')
@@ -11,7 +11,7 @@
  gstfft_dep = dependency('gstreamer-fft-1.0', version : gst_req,
      fallback : 'gst-plugins-base', 'fft_dep')
  gstriff_dep = dependency('gstreamer-riff-1.0', version : gst_req,
-@@ -587,13 +589,7 @@ else
+@@ -575,13 +577,7 @@ else
    pathsep = ':'
  endif
  
@@ -25,10 +25,10 @@
  
  if have_orcc
    update_orc_dist_files = find_program('scripts/update-orc-dist-files.py')
-Index: gst-plugins-bad-1.28.0/ext/meson.build
+Index: gst-plugins-bad-1.28.5/ext/meson.build
 ===================================================================
---- gst-plugins-bad-1.28.0.orig/ext/meson.build
-+++ gst-plugins-bad-1.28.0/ext/meson.build
+--- gst-plugins-bad-1.28.5.orig/ext/meson.build
++++ gst-plugins-bad-1.28.5/ext/meson.build
 @@ -1,87 +1,5 @@
 -subdir('aes')
 -subdir('analyticsoverlay')

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ChangeLog -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ChangeLog Changed

@@ -1,3 +1,639 @@
+=== release 1.28.5 ===
+
+2026-07-08 23:42:39 +0200  Tim-Philipp Müller <tim@centricular.com>
+
+	* gst-plugins-bad.doap:
+	* meson.build:
+	  Release 1.28.5
+
+2026-06-26 11:45:51 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/librfb/rfbdecoder.c:
+	  rfbsrc: Read the correct number of bytes for color values
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12077>
+
+2026-06-26 11:19:41 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/librfb/rfbdecoder.c:
+	  rfbsrc: Use correct bpp for copying hextile data
+	  Fix provided by Clouditera Security, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5173
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12077>
+
+2026-06-25 11:47:44 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/dtls/gstdtlsconnection.c:
+	  dtlsconnection: Allocate large enough buffer for the peer certificate subject DN
+	  Fix provided by Clouditera Security.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5172
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12076>
+
+2026-06-25 11:18:53 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/webrtc/webrtcsdp.c:
+	  webrtcsdp: Fix inverted fingerprint existence logic
+	  Fix provided by Clouditera Security, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5171
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12075>
+
+2026-06-24 11:00:43 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/closedcaption/ccutils.c:
+	* gst/closedcaption/gstccconverter.c:
+	  ccconverter: Use truncated length when converting CEA608 raw to CEA708 CDP
+	  Also make sure no caller passes too much data to cc_buffer_push_separated()
+	  and truncate internally to the absolute maximum.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5161
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12074>
+
+2026-06-24 09:58:28 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst-libs/gst/codecparsers/gstvp9parser.c:
+	  vp9parser: Check that enough data is available for parsing superframe info
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5160
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12073>
+
+2026-06-22 14:02:28 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst-libs/gst/codecparsers/gsth266parser.c:
+	  h266parser: Check bounds before writing to CTU entrypoint array
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5156
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12070>
+
+2026-06-22 13:44:29 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst-libs/gst/codecparsers/gsth266parser.c:
+	  h266parser: Avoid out-of-bounds read if too many exp slices are signalled
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5155
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12069>
+
+2026-06-22 13:44:12 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst-libs/gst/codecparsers/gsth266parser.c:
+	  h266parser: Fix typos in warning messages
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12069>
+
+2026-06-17 11:04:05 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/videoparsers/gstmpeg4videoparse.c:
+	  mpeg4videoparse: Ensure enough config data is available before extracting profile/level
+	  Patch provided by Ramesh Adhikari, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5110
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12057>
+
+2026-07-03 08:30:32 +0900  Seungha Yang <seungha@centricular.com>
+
+	* gst-libs/gst/d3d12/gstd3d12device.cpp:
+	  d3d12: Fix command list leak
+	  Unref command list after use
+	  Fixes: https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5200
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12006>
+
+2026-07-01 16:14:55 +0900  amy.ko <amy.ko@lge.com>
+
+	* sys/v4l2codecs/gstv4l2decoder.c:
+	  gstv4l2decoder: Fix media_fd leak when video_fd open fails
+	  When opening v4l2 decoder, media_fd and video_fd are opened.
+	  However, there is no code to close media_fd when opening
+	  video_fd fails. This results in a media_fd leakage.
+	  Close media_fd by calling gst_v4l2_decoder_close() in the
+	  video_fd error path.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11999>
+
+2026-06-15 15:40:17 +0200  Christopher Meltzer <christme@axis.com>
+
+	* ext/curl/gstcurlsmtpsink.c:
+	  gstcurlsmtpsink: Use the correct content-type if known
+	  Previously gstcurlsmtpsink put "application/octet-stream" as the
+	  content-type. This caused mail clients to save the content to a file
+	  instead of displaying it.
+	  Now we instead use the content-type of the sink if it is known,
+	  otherwise we use "application/octet-stream" as the content type.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11991>
+
+2026-07-01 15:21:44 +0100  Walisiewicz <alexei.walisiewicz@v-nova.com>
+
+	* gst-libs/gst/codecparsers/gsth266parser.c:
+	  h266parser: Heap-allocate parameter sets before parse to avoid stack overflow
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11990>
+
+2026-07-01 09:57:38 -0400  Julian Bouzas <julian.bouzas@collabora.com>
+
+	* gst/videoparsers/gsth264parse.c:
+	* gst/videoparsers/gsth265parse.c:
+	* gst/videoparsers/gstmpegvideoparse.c:
+	* gst/videoparsers/gstvideoparseutils.c:
+	* gst/videoparsers/gstvideoparseutils.h:
+	  videoparsersbad: Always clear LCEVC enhancement data when resetting frame
+	  There is no need to keep the LCEVC data from an old frame as the data is only
+	  useful for the frame it is associated with. This also fixes a memleak when
+	  running gst-discoverer-1.0.
+	  Fixes #5192
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11987>
+
+2026-06-26 17:23:39 +1000  Matthew Waters <matthew@centricular.com>
+
+	* ext/webrtc/gstwebrtcbin.c:
+	* ext/webrtc/transportreceivebin.c:
+	* ext/webrtc/transportreceivebin.h:
+	* ext/webrtc/utils.c:
+	* ext/webrtc/utils.h:
+	* ext/webrtc/webrtcsdp.c:
+	* ext/webrtc/webrtcsdp.h:
+	  webrtcbin: validate remote fingerprints match peer dtls certificate
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11963>
+
+2026-06-26 16:10:40 +1000  Matthew Waters <matthew@centricular.com>
+
+	* ext/webrtc/transportreceivebin.c:
+	* ext/webrtc/transportreceivebin.h:
+	  webrtc/transportreceivebin: remove unused rt(c)p probe fields
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11963>
+
+2026-06-26 14:53:54 -0400  Xavier Claessens <xclaessens@netflix.com>
+
+	* ext/qroverlay/gstqroverlay.c:
+	  qroverlay: Fix use after free bug
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11960>
+
+2026-06-23 19:46:32 +1000  Jan Schmidt <jan@centricular.com>
+
+	* gst/mpegtsmux/tsmux/tsmux.c:
+	  mpegtsmux: Always assign PTS to output buffers in CBR mode
+	  !6380 introduced a regression where some output buffers
+	  might not receive a PTS in CBR mode
+	  Fixes #5151
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11955>
+
+2026-06-24 17:41:28 +0900  Jeehyun Lee <jeehyun.lee@lge.com>
+
+	* gst/rtp/gstrtpsink.c:
+	  rtpsink: fix mutex not unlocked on invalid URI in set_property
+	  If gst_uri_from_string() returns NULL, the function breaks out of the
+	  switch without calling GST_RTP_SINK_UNLOCK, leaving the mutex locked.
+	  Any subsequent call to set_property on the same object will deadlock.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11949>
+
+2026-06-17 10:03:36 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst-libs/gst/codecparsers/gsth266parser.c:
+	  h266parser: Check aspect ratio index against lookup table length
+	  Patch provided by Ramesh Adhikari, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5109
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11942>
+
+2026-06-16 15:23:13 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/videoparsers/gsth264parse.c:
+	  h264parse: Check for enough slice header data being available
+	  Patch provided by Ramesh Adhikari, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5108
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11941>
+
+2026-06-19 15:42:52 +0200  Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+
+	* gst-libs/gst/va/gstvasurfacecopy.c:
+	  va: surfacecopy: get surface's image in `gst_va_surface_copy`
+	  Since 2021 the function `gst_va_surface_copy()` has been incomplete, since even
+	  the image is created, it wasn't retrieved from the surface.
+	  It went unnoticed on iHD Intel platforms because `vaCopy()` was used, but not in
+	  Mesa.
+	  The fix is just to actually retrieve the image from the source surface.
+	  Also, left a notice that derived could be used and it could be more efficient in
+	  Mesa after the fix is merged, but we would use the mechanism to check the
+	  driver's implementation _and_ version.
+	  Fixes: https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/3906
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11935>
+
+2026-06-18 10:10:27 +0000  Christoph Seitz <christoph.seitz@infineon.com>
+
+	* ext/avtp/gstavtpbasedepayload.c:
+	  avtp: Correct ptime generation from avtp timestamp
+	  Fix the calculation of the presentation time from the avtp by
+	  properly adjusting for the rollover of the reference or avtp
+	  timestamp. The adjustment is needed whenever the distance
+	  between there reference timestamp and avtp timestamp is lager
+	  then half the avtp timestamp size.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11934>
+
+2026-06-15 19:50:30 +1000  Jan Schmidt <jan@centricular.com>
+
+	* tests/check/elements/netsim.c:
+	  netsim: Fix racy test failures
+	  This test stress tests netsim by switching state
+	  rapidly while sending buffers and events through.
+	  That means that events sometimes land on a flushing pad
+	  and don't get sent, yielding sticky event errors
+	  that need filtering away.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11933>
+
+2026-06-22 12:53:52 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/pnm/gstpnmdec.c:
+	* gst/pnm/gstpnmutils.h:
+	  pnmdec: Avoid overflows when calculating frame sizes
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11926>
+
+2026-06-22 12:39:57 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/videoparsers/gsth264parse.c:
+	* gst/videoparsers/gsth265parse.c:
+	  h2654parse: Unset GValue in every code path
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11921>
+
+2026-06-22 12:34:02 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst-libs/gst/codecparsers/gsth266parser.c:
+	  h266parser: Use long bit skipping function for potentially large values
+	  The other one is going to assert for more than 64 bits.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11920>
+
+2026-03-26 17:08:26 +0900  Seungha Yang <seungha@centricular.com>
+
+	* gst-libs/gst/codecs/gsth265decoder.c:
+	  h265decoder: Fix HEVC with alpha decoding
+	  HEVC multi-layer streams such as HEVC with alpha contain slices
+	  with non-zero nuh_layer_id that should be handled differently, but
+	  the base class does not distinguish slices belonging to different
+	  layers.
+	  Until proper multi-layer decoding support is implemented, ignore
+	  any NAL units with non-zero nuh_layer_id as specified by the spec.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11916>
+
+2026-06-20 17:40:00 +1000  Jan Schmidt <jan@centricular.com>
+
+	* gst/mpegtsdemux/mpegtspacketizer.c:
+	* tests/check/elements/mpegtsdemux.c:
+	* tests/files/test_pcr_rollover.ts:
+	  mpegtsdemux: Improve PTS rollover handling in ignore-pcr mode
+	  When ignore-pcr is true, timestamp epoch detection could get confused
+	  by PTS jumping around as we cross the rollover threshold - either from
+	  PTSes being out of order in a stream, or from conversions across the
+	  different streams in a mux. This adds handling for the PTS crossing
+	  backward into the previous epoch correctly, without accidentally
+	  jumping a full 26-hour PCR epoch into the future.
+	  Add a test file and a unit test that tsdemux correctly
+	  processes PCR/PTS rollover when in ignore-pcr=true mode.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11905>
+
+2026-06-19 12:13:15 -0400  Dominique Leroux <dominique.p.leroux@gmail.com>
+
+	* sys/androidmedia/gstamcvideodec.c:
+	  amcviddec: Fix double-free happening when codec gets reconfigured
+	  In basic usage (configure -> decode -> destroy), freeing codec_data and
+	  leaving the pointer dangling is harmless. But if the decoder is reconfigured
+	  after gst_amc_video_dec_stop (as opposed to getting destroyed), then
+	  existing logic will interpret the non-null codec_data as being valid and
+	  cause use-after-free, further leading to freeing it (again) when the codec
+	  is stopped a second time.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11902>
+
+2026-06-19 08:39:36 +0200  François Laignel <francois@centricular.com>
+
+	* gst/mxf/mxfdemux.c:
+	  mxfdemux: fix remaining offsets index entry insertion call site
+	  ... which I missed as part of:
+	  https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11882
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11892>
+
+2026-06-18 15:20:58 +0200  François Laignel <francois@centricular.com>
+
+	* gst/mxf/mxfdemux.c:
+	  mxfdemux: fix essence track offsets array population
+	  The essence track offsets array provides a way to get access to an essence
+	  track even when the container doesn't provide an index. It is populated on the
+	  go as entry are being processed and checked in priority when looking for an
+	  entry.
+	  Code paths adding entries to the offsets array assumed a sequentially
+	  increasing sequence, which didn't comply with seeks nor reverse playback.
+	  Most of the time, this would remain unnoticed since other methods would allow
+	  retrieving the entry.
+	  However, an assertion could fail in the following situation: a bogus package
+	  for which one track presents one additional entry compared to the other tracks
+	  and this additional entry is not included in the index table. If a seek was
+	  performed the first time the stream was played and the stream reached the EOS,
+	  the additional entry (not part of the index and not part of the offsets) would
+	  lead to executing a code path asserting this entry's position should be <= the
+	  offsets len, following the assumption that all entries would be added
+	  sequentially. But because of the seek, the regular code path hadn't added some
+	  of the post seek entries (because they were not the next expected entries),
+	  hence an assertion failure on the last entry.
+	  This commit adds all new entries to the offsets array as soon as they are found
+	  and whatever their arrival position. The offsets array is now created with the
+	  essence track instead of creating it on the first entry. Therefore, it is no
+	  longer needed to check whether it is valid.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11892>
+
+2026-06-17 16:23:53 +0200  François Laignel <francois@centricular.com>
+
+	* gst/mxf/mxfdemux.c:
+	* gst/mxf/mxfdemux.h:
+	  mxdemux: index entry: use intialized
+	  ... instead of the offset != 0 sentinel.
+	  A previous version of the code used 0 as an offset sentinel to state & check the
+	  entry was initialized or not. Then the field `initialized` was added, but some
+	  parts of the code keep checking the sentinel.
+	  This commit relies on `initialized` which makes it clearer what the intention is.
+	  It also makes sure code is capable of dealing with gaps.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11892>
+
+2026-06-17 15:48:32 +0200  Jan Alexander Steffens (heftig) <jan.steffens@ltnglobal.com>
+
+	* gst/rtmp2/rtmp/rtmpclient.c:
+	  rtmp2: Remove socket timeout after handshake completes
+	  A server might send us nothing when we're publishing (rtmp2sink), not
+	  even RTMP acknowledgement messages, which causes fatal timeouts as of
+	  20adfe5659f8.
+	  See: https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/8989#note_3441479
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11890>
+
+2025-05-16 12:47:35 +0200  Piotr Brzeziński <piotr@centricular.com>
+
+	* gst/rtmp2/rtmp/rtmpconnection.c:
+	  rtmp2: Don't retry on G_IO_ERROR_TIMED_OUT
+	  Retrying forever on a timeout made rtmp2sink prone to hanging if the server misbehaves.
+	  When that happens, rtmp2sink becomes impossible to stop/EOS by normal means.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11889>
+
+2026-06-16 10:30:54 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/vmnc/vmncdec.c:
+	  vnmdec: Avoid integer overflows when rectangle positions and sizes
+	  Patch based on a patch by Junyi Liu, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5107
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11876>
+
+2026-06-16 09:30:00 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/pcapparse/gstpcapparse.c:
+	  pcapparse: Add missing bounds checks to ensure packets are large enough
+	  Patch based on a patch by Junyi Liu, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5106
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11874>
+
+2026-06-15 17:57:00 +0200  Tomas Granath <tomas.granath@outlook.com>
+
+	* gst/mpegdemux/gstmpegdemux.c:
+	  mpegpsdemux: Release stream lock when seeking fails
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11871>
+
+2026-06-14 22:03:25 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/librfb/rfbdecoder.c:
+	  librfb: Validate framebuffer update rectangles against the framebuffer size
+	  Patch provided by Junyi Liu, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5105
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11868>
+
+2026-06-12 13:27:54 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* meson.build:
+	  Back to development after 1.28.4
+
+=== release 1.28.4 ===
+
+2026-06-12 13:19:43 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* gst-plugins-bad.doap:
+	* meson.build:
+	  Release 1.28.4
+
+2026-06-04 11:47:12 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/mxf/mxfdemux.c:
+	* gst/mxf/mxfmetadata.c:
+	* gst/mxf/mxfmetadata.h:
+	* gst/mxf/mxftypes.c:
+	* gst/mxf/mxftypes.h:
+	  mxfdemux: Use unsigned integers in more places and don't truncate 64 bit integers
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5048
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11837>
+
+2026-06-09 09:40:41 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/va/gstjpegdecoder.c:
+	  vajpegdecoder: Validate that enough data is available for the current JPEG segment
+	  gst_jpeg_parse() does not ensure this and relies on the caller to collect enough
+	  data. All other users of the function are doing this correctly.
+	  Here we can directly error out if not enough data is available as we require
+	  parsing input.
+	  Patch provided by Junyi Liu, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5104
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11834>
+
+2026-06-09 09:26:38 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst-libs/gst/codecparsers/gstav1parser.c:
+	  av1parser: Fix bytes/bits confusion when parsing tile data size
+	  Which would then later lead to an assertion.
+	  Patch provided by Junyi Liu, who also reported this.
+	  Fixes https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5103
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11827>
+
+2026-06-10 12:17:10 +0300  Vivia Nikolaidou <vivia@ahiru.eu>
+
+	* gst/mpegtsdemux/mpegtspacketizer.c:
+	  mpegtspacketizer: Do not seek before the first PCR
+	  It can be that the first PCR offset is slightly non-zero (for instance, video
+	  starts mid-GOP). In that case, when we try to seek earlier than that (usually to
+	  zero, see also SEEK_TIMESTAMP_OFFSET which will still throw us to zero when
+	  we're seeking before 2.5sec) we shouldn't fail/EOS. Just return the first PCR
+	  instead.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11786>
+
+2026-06-05 12:50:39 +0900  Seungha Yang <seungha@centricular.com>
+
+	* sys/d3d12/gstd3d12decoder.cpp:
+	  d3d12decoder: Use subresource index as view ID directly for tier-1 decoders
+	  D3D12 Tier-1 decoding uses a texture-array DPB. Some drivers seem to
+	  expect DXVA view IDs to match subresource index, like D3D11 decoding.
+	  Use the actual subresource index as the view ID in this mode instead of
+	  assigning a separate internal slot ID
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11781>
+
+2026-06-05 12:25:14 +0900  Seungha Yang <seungha@centricular.com>
+
+	* sys/d3d12/gstd3d12decoder.cpp:
+	  d3d12decoder: Set colorspace to conversion args
+	  Don't use RGB color space for YUV formats
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11781>
+
+2026-06-05 10:07:59 +0900  Seungha Yang <seungha@centricular.com>
+
+	* gst-libs/gst/dxva/gstdxvavp8decoder.cpp:
+	* gst-libs/gst/dxva/gstdxvavp9decoder.cpp:
+	  dxva: Fix VP8/VP9 decoding on Qualcomm GPUs
+	  AssociatedFlag must be zero for valid reference frames according
+	  to the DXVA VP8/VP9 specification
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11781>
+
+2026-05-11 19:11:01 +0200  Jakub Adam <jakub.adam@collabora.com>
+
+	* gst-libs/gst/mse/meson.build:
+	* tests/check/libs/gstlibscpp.cc:
+	* tests/check/meson.build:
+	  meson: fix building -bad tests with disabled mse
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11617>
+
+2026-05-12 16:08:30 +0200  Carlos Falgueras García <cfalgueras@fluendo.com>
+
+	* tests/check/libs/av1parser.c:
+	  tests: fix support with glib <= 2.67.2
+	  These tests use "g_memdup2()" but they don't include
+	  "gst/glib-compat-private.h", which makes the compilation fail when linking
+	  against Glib <= 2.67.2 as "g_memdup2()" was included at 2.67.3
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11618>
+
+2026-04-27 17:03:14 +0800  Hou Qi <qi.hou@nxp.com>
+
+	* gst/camerabin2/gstwrappercamerabinsrc.c:
+	  camerabin: Fix caps negotiation when starting to capture
+	  Use BLOCK_DOWNSTREAM probe instead of IDLE probe when starting image and
+	  video capture to ensure proper caps negotiation with downstream elements.
+	  Using an IDLE probe could allow buffers to flow before caps negotiation
+	  completes with the downstream encodebin elements, causing the camerabinsrc
+	  to select caps that are incompatible with the video or image encoder.
+	  BLOCK_DOWNSTREAM ensures the pipeline is blocked during reconfiguration
+	  and caps negotiation completes before buffers flow.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11774>
+
+2026-05-26 13:22:03 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/ndk/gstamc-codec-ndk.c:
+	  androidmedia: Fix typo in error message
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11692>
+
+2026-05-25 19:05:44 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamc.c:
+	  amc: Don't try printing NULL caps
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11688>
+
+2026-05-25 18:50:39 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamcvideodec.c:
+	  amcvideodec: Don't keep crop-rectangle uninitialized if not specified
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11686>
+
+2026-05-22 16:56:12 +0900  MilkClouds <milkclouds00@gmail.com>
+
+	* sys/wasapi2/gstwasapi2rbuf.cpp:
+	  wasapi2: Don't reset process loopback capture client
+	  The process loopback virtual device does not resume capture after
+	  IAudioClient::Reset(): a later Start() returns S_OK but no buffers
+	  are delivered and the event handle is never signalled, so the
+	  pipeline stalls.
+	  Two paths call Reset() on the capture client:
+	  - the warm-up in gst_wasapi2_rbuf_ctx_init() (Start/Stop/Reset). It
+	  exists to hide idle-hardware Start() latency and is meaningless for
+	  the virtual process loopback device. Skip it for process loopback.
+	  - RbufCtx::Stop(). Skip the Reset() there for process loopback so the
+	  client survives a stop/start (pause/resume) cycle.
+	  Start/Stop/Start without Reset() works correctly, so only Reset()
+	  needs to be avoided.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11683>
+
+2026-05-13 10:52:53 -0400  Xavier Claessens <xclaessens@netflix.com>
+
+	* sys/va/gstvafilter.c:
+	* sys/va/gstvafilter.h:
+	  vafilter: Add support for premultiplied alpha
+	  This is a backport of a part of
+	  https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11619.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11675>
+
+2026-02-03 10:59:13 +0100  Marcus Hanestad <marlhan@proton.me>
+
+	* sys/androidmedia/gstamcaudiodec.c:
+	  androidmedia: support decoding flac
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11647>
+
+2026-05-15 15:56:45 +0800  Cheah, Vincent Beng Keat <vincent.beng.keat.cheah@intel.com>
+
+	* gst-libs/gst/va/gstvadisplay_drm.c:
+	  va: drm: Fix fd leak and return type in create_va_display
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11642>
+
+2026-03-17 15:03:09 +0530  Nirbheek Chauhan <nirbheek@centricular.com>
+
+	* ext/vulkan/vkupload.c:
+	  vulkanupload: Don't reallocate the pool when the framerate changes
+	  This causes an unnecessary stall in pipelines where the framerate
+	  changes frequently because we're decoding, for instance, fmp4.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11628>
+
+2026-05-08 15:32:02 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamc.c:
+	  androidmedia: Add H265 main-still-picture profile mapping
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11614>
+
+2026-05-08 15:28:58 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamc-constants.h:
+	* sys/androidmedia/gstamc.c:
+	  androidmedia: Add some more AAC profile mappings
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11614>
+
+2026-05-08 15:16:15 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamc.c:
+	* sys/androidmedia/gstamcaudiodec.c:
+	  androidmedia: Add caps mappings for AC3/EAC3/AC4
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11614>
+
+2026-05-08 15:12:01 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamc.c:
+	* sys/androidmedia/gstamcvideodec.c:
+	* sys/androidmedia/gstamcvideoenc.c:
+	  androidmedia: Add caps mappings for WMV and VC1
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11614>
+
+2026-05-08 14:48:40 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamc.c:
+	  androidmedia: Add video/mp43 as alias for video/mp4v-es
+	  Some devices use it for the same codec.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11614>
+
+2026-05-08 14:39:21 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamc.c:
+	* sys/androidmedia/gstamcaudiodec.c:
+	  androidmedia: Add audio/mpeg-L1 caps mapping
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11614>
+
+2026-05-08 13:50:02 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstahcsrc.c:
+	  ahcsrc: Register exposure-mode property for GstPhotography interface
+	  This was added some years ago to the interface, which was technically a breaking
+	  change. Now the property needs to be provided by all implementers of the
+	  interface.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11613>
+
+2026-05-08 12:56:37 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamcaudiodec.c:
+	* sys/androidmedia/gstamcvideodec.c:
+	* sys/androidmedia/gstamcvideoenc.c:
+	  androidmedia: Don't print error logs if downstream returns flushing / EOS
+	  Just log them normally as debug logs.
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11610>
+
+2026-04-07 17:31:50 +0900  Seungmin Lee <seungmin.lee.cpp@navercorp.com>
+
+	* ext/svtav1/gstsvtav1enc.c:
+	* ext/svtav1/meson.build:
+	  svtav1enc: Scale MDCV and CLL to SVT-AV1's expected units
+	  Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11609>
+
+2026-05-11 18:33:25 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* meson.build:
+	  Back to development after 1.28.3
+
 === release 1.28.3 ===
 
 2026-05-11 18:28:12 +0100  Tim-Philipp Müller <tim@centricular.com>

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/RELEASE -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/RELEASE Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/avtp/gstavtpbasedepayload.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/avtp/gstavtpbasedepayload.c Changed

@@ -246,15 +246,17 @@
   ref_low = ref & 0xFFFFFFFFULL;
   ptime = (ref & 0xFFFFFFFF00000000ULL) | tstamp;
 
-  /* If 'ptime' is less than the our reference time, it means the higher part
-   * from 'ptime' needs to be incremented by 1 in order reflect the correct
-   * presentation time.
+  /* When ever the distance between the reference time and the timestamp
+   * is greater than half the 32-bit range, we adjust the upper 32 bits
+   * of the presentation time to compensate for the rollover of the
+   * avtp or reference timestamp.
    */
-  if (tstamp < G_MAXINT32 && ref_low > G_MAXINT32)
-    ptime += G_MAXUINT32 + 1;
-
-  if (tstamp < G_MAXINT32 && ref_low > G_MAXINT32 && ptime > G_MAXUINT32)
-    ptime -= G_MAXUINT32 + 1;
+  if (tstamp < G_MAXINT32 && ref_low > G_MAXINT32
+      && ref_low - tstamp > G_MAXINT32)
+    ptime += G_GUINT64_CONSTANT (0x100000000);
+  if (tstamp > G_MAXINT32 && ref_low < G_MAXINT32
+      && tstamp - ref_low > G_MAXINT32)
+    ptime -= G_GUINT64_CONSTANT (0x100000000);
 
   GST_LOG_OBJECT (avtpbasedepayload, "AVTP presentation time %" GST_TIME_FORMAT,
       GST_TIME_ARGS (ptime));

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/curl/gstcurlsmtpsink.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/curl/gstcurlsmtpsink.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/dtls/gstdtlsconnection.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/dtls/gstdtlsconnection.c Changed

@@ -1114,16 +1114,29 @@
   } else {
     bio = BIO_new (BIO_s_mem ());
     if (bio) {
-      gchar buffer2048;
       gint len;
+      gint read_len;
 
       len =
           X509_NAME_print_ex (bio,
           X509_get_subject_name (X509_STORE_CTX_get0_cert (x509_ctx)), 1,
           XN_FLAG_MULTILINE);
-      BIO_read (bio, buffer, len);
-      bufferlen = '\0';
-      GST_DEBUG_OBJECT (self, "Peer certificate received:\n%s", buffer);
+
+      if (len > 0) {
+        gchar *buffer;
+
+        buffer = g_new (gchar, (gsize) len + 1);
+        read_len = BIO_read (bio, buffer, len);
+        if (read_len > 0) {
+          bufferread_len = '\0';
+          GST_DEBUG_OBJECT (self, "Peer certificate received:\n%s", buffer);
+        } else {
+          GST_DEBUG_OBJECT (self, "failed to read certificate subject");
+        }
+        g_free (buffer);
+      } else {
+        GST_DEBUG_OBJECT (self, "failed to read certificate subject");
+      }
       BIO_free (bio);
     } else {
       GST_DEBUG_OBJECT (self, "failed to create certificate print membio");

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/qroverlay/gstqroverlay.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/qroverlay/gstqroverlay.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/svtav1/gstsvtav1enc.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/svtav1/gstsvtav1enc.c Changed

@@ -26,6 +26,8 @@
 #include <gst/video/video.h>
 #include <gst/video/gstvideoencoder.h>
 
+#include <math.h>
+
 #if !SVT_AV1_CHECK_VERSION(1,2,1)
 #define SVT_AV1_RC_MODE_CQP_OR_CRF 0
 #define SVT_AV1_RC_MODE_VBR 1
@@ -556,6 +558,14 @@
   }
 }
 
+static inline guint16
+mdcv_to_svtav1 (guint16 x)
+{
+  gdouble v = (gdouble) x / 50000;
+  v = round (v * (1 << 16));
+  return GUINT16_TO_BE (v > 65535 ? 65535 : (guint16) v);
+}
+
 static gboolean
 gst_svtav1enc_configure_svt (GstSvtAv1Enc * svtav1enc)
 {
@@ -762,26 +772,38 @@
   GstVideoMasteringDisplayInfo master_display_info;
   if (gst_video_mastering_display_info_from_caps (&master_display_info,
           svtav1enc->state->caps)) {
+    gdouble max_lum, min_lum;
+
     svtav1enc->svt_config->mastering_display.r.x =
-        master_display_info.display_primaries0.x;
+        mdcv_to_svtav1 (master_display_info.display_primaries0.x);
     svtav1enc->svt_config->mastering_display.r.y =
-        master_display_info.display_primaries0.y;
+        mdcv_to_svtav1 (master_display_info.display_primaries0.y);
     svtav1enc->svt_config->mastering_display.g.x =
-        master_display_info.display_primaries1.x;
+        mdcv_to_svtav1 (master_display_info.display_primaries1.x);
     svtav1enc->svt_config->mastering_display.g.y =
-        master_display_info.display_primaries1.y;
+        mdcv_to_svtav1 (master_display_info.display_primaries1.y);
     svtav1enc->svt_config->mastering_display.b.x =
-        master_display_info.display_primaries2.x;
+        mdcv_to_svtav1 (master_display_info.display_primaries2.x);
     svtav1enc->svt_config->mastering_display.b.y =
-        master_display_info.display_primaries2.y;
+        mdcv_to_svtav1 (master_display_info.display_primaries2.y);
     svtav1enc->svt_config->mastering_display.white_point.x =
-        master_display_info.white_point.x;
+        mdcv_to_svtav1 (master_display_info.white_point.x);
     svtav1enc->svt_config->mastering_display.white_point.y =
-        master_display_info.white_point.y;
+        mdcv_to_svtav1 (master_display_info.white_point.y);
+
+    max_lum =
+        round ((gdouble) master_display_info.max_display_mastering_luminance /
+        10000 * (1 << 8));
+    min_lum =
+        round ((gdouble) master_display_info.min_display_mastering_luminance /
+        10000 * (1 << 14));
     svtav1enc->svt_config->mastering_display.max_luma =
-        master_display_info.max_display_mastering_luminance;
+        GUINT32_TO_BE ((guint32) max_lum);
     svtav1enc->svt_config->mastering_display.min_luma =
-        master_display_info.min_display_mastering_luminance;
+        GUINT32_TO_BE ((guint32) min_lum);
+#if !(SVT_AV1_CHECK_VERSION(3, 0, 0))
+    svtav1enc->svt_config->high_dynamic_range_input = TRUE;
+#endif
   } else {
     memset (&svtav1enc->svt_config->mastering_display,
         0, sizeof (svtav1enc->svt_config->mastering_display));
@@ -791,9 +813,9 @@
   if (gst_video_content_light_level_from_caps (&content_light_level,
           svtav1enc->state->caps)) {
     svtav1enc->svt_config->content_light_level.max_cll =
-        content_light_level.max_content_light_level;
+        GUINT16_TO_BE (content_light_level.max_content_light_level);
     svtav1enc->svt_config->content_light_level.max_fall =
-        content_light_level.max_frame_average_light_level;
+        GUINT16_TO_BE (content_light_level.max_frame_average_light_level);
   } else {
     memset (&svtav1enc->svt_config->content_light_level,
         0, sizeof (svtav1enc->svt_config->content_light_level));

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/svtav1/meson.build -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/svtav1/meson.build Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/vulkan/vkupload.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/vulkan/vkupload.c Changed

@@ -616,23 +616,47 @@
 static gboolean
 _raw_to_image_set_caps (gpointer impl, GstCaps * in_caps, GstCaps * out_caps)
 {
+  GstVideoInfo in_info, out_info;
   struct RawToImageUpload *raw = impl;
 
-  if (!gst_video_info_from_caps (&raw->in_info, in_caps))
+  if (!gst_video_info_from_caps (&in_info, in_caps))
     return FALSE;
 
-  if (!gst_video_info_from_caps (&raw->out_info, out_caps))
+  if (!gst_video_info_from_caps (&out_info, out_caps))
     return FALSE;
 
   if (raw->in_pool) {
-    if (raw->in_pool_active) {
-      gst_buffer_pool_set_active (raw->in_pool, FALSE);
+    GstVideoInfo copy;
+    gboolean realloc_pool = FALSE;
+
+    // Check that all caps fields are the same, except for the framerate which
+    // can be changed freely without re-allocating the buffer pool.
+    copy = in_info;
+    copy.fps_n = raw->in_info.fps_n;
+    copy.fps_d = raw->in_info.fps_d;
+    if (!gst_video_info_is_equal (&copy, &raw->in_info))
+      realloc_pool = TRUE;
+
+    copy = out_info;
+    copy.fps_n = raw->out_info.fps_n;
+    copy.fps_d = raw->out_info.fps_d;
+    if (!gst_video_info_is_equal (&copy, &raw->out_info))
+      realloc_pool = TRUE;
+
+    if (realloc_pool) {
+      GST_INFO ("Reallocating pool");
+      if (raw->in_pool_active) {
+        gst_buffer_pool_set_active (raw->in_pool, FALSE);
+      }
+      raw->in_pool_active = FALSE;
+      gst_object_unref (raw->in_pool);
+      raw->in_pool = NULL;
     }
-    raw->in_pool_active = FALSE;
-    gst_object_unref (raw->in_pool);
-    raw->in_pool = NULL;
   }
 
+  raw->in_info = in_info;
+  raw->out_info = out_info;
+
   return TRUE;
 }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/webrtc/gstwebrtcbin.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/webrtc/gstwebrtcbin.c Changed

@@ -872,6 +872,28 @@
   return stream;
 }
 
+static gboolean
+match_stream_for_dtls_transport (TransportStream * trans,
+    GstWebRTCDTLSTransport * transport)
+{
+  return trans->transport == transport;
+}
+
+static TransportStream *
+_find_transport_for_dtls_transport (GstWebRTCBin * webrtc,
+    GstWebRTCDTLSTransport * transport)
+{
+  TransportStream *stream;
+
+  stream = _find_transport (webrtc, transport,
+      (FindTransportFunc) match_stream_for_dtls_transport);
+
+  GST_TRACE_OBJECT (webrtc,
+      "Found transport %" GST_PTR_FORMAT " for dtls transport %" GST_PTR_FORMAT,
+      stream, transport);
+
+  return stream;
+}
 
 typedef gboolean (*FindPadFunc) (GstWebRTCBinPad * p1, gconstpointer data);
 
@@ -2255,9 +2277,62 @@
 }
 
 static void
+validate_transport_fingerprint (GstWebRTCSessionDescription *
+    remote_description, TransportStream * stream)
+{
+  if (!remote_description || !stream) {
+    return;
+  }
+  // early return if the fingerprint has already been validated.
+  if (stream->receive_bin->validated_fingerprint)
+    return;
+
+  GChecksumType checksum;
+  char *fingerprint = _get_fingerprint_from_sdp_media (remote_description->sdp,
+      stream->session_id, &checksum);
+
+  if (!fingerprint)
+    return;
+
+  char *peer_pem;
+  g_object_get (stream->transport, "remote-certificate", &peer_pem, NULL);
+  if (peer_pem) {
+    char *expected_fingerprint =
+        _generate_fingerprint_from_certificate (peer_pem, checksum);
+    if (g_strcmp0 (expected_fingerprint, fingerprint) == 0) {
+      transport_receive_bin_set_data_receive_state (stream->receive_bin,
+          RECEIVE_STATE_PASS);
+      stream->receive_bin->validated_fingerprint = TRUE;
+    }
+
+    g_free (expected_fingerprint);
+    g_free (peer_pem);
+  }
+  g_free (fingerprint);
+}
+
+static void
 _on_dtls_transport_notify_state (GstWebRTCDTLSTransport * transport,
     GParamSpec * pspec, GstWebRTCBin * webrtc)
 {
+  GstWebRTCDTLSTransportState dtls_state;
+
+  g_object_get (transport, "state", &dtls_state, NULL);
+
+  if (dtls_state == GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTED) {
+    TransportStream *stream =
+        _find_transport_for_dtls_transport (webrtc, transport);
+    GstWebRTCSessionDescription *sdp = NULL;
+
+    if (webrtc->current_remote_description) {
+      sdp = webrtc->current_remote_description;
+    } else if (webrtc->pending_remote_description) {
+      sdp = webrtc->pending_remote_description;
+    }
+
+    validate_transport_fingerprint (sdp, stream);
+  }
+
   _update_peer_connection_state (webrtc);
 }
 
@@ -6013,7 +6088,7 @@
    * the dtlssrtp elements before the ssl direction has been set which will
    * throw SSL errors */
   if (receive_state != RECEIVE_STATE_UNSET)
-    transport_receive_bin_set_receive_state (stream->receive_bin,
+    transport_receive_bin_set_dtls_receive_state (stream->receive_bin,
         receive_state);
 }
 
@@ -6153,7 +6228,7 @@
   stream->active = TRUE;
 
   receive = TRANSPORT_RECEIVE_BIN (stream->receive_bin);
-  transport_receive_bin_set_receive_state (receive, RECEIVE_STATE_PASS);
+  transport_receive_bin_set_dtls_receive_state (receive, RECEIVE_STATE_PASS);
 }
 
 static gboolean
@@ -6257,6 +6332,7 @@
 
     stream = _get_or_create_transport_stream (webrtc, transport_idx,
         _message_media_is_datachannel (sdp->sdp, transport_idx));
+    validate_transport_fingerprint (webrtc->current_remote_description, stream);
     if (!bundled) {
       /* When bundling, these were all set up above, but when not
        * bundling we need to do it now */
@@ -6295,7 +6371,7 @@
      * this bundle is completely inactive */
     GST_LOG_OBJECT (webrtc,
         "All mlines in bundle %u are inactive. Blocking receiver", bundle_idx);
-    transport_receive_bin_set_receive_state (bundle_stream->receive_bin,
+    transport_receive_bin_set_dtls_receive_state (bundle_stream->receive_bin,
         RECEIVE_STATE_BLOCK);
   }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/webrtc/transportreceivebin.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/webrtc/transportreceivebin.c Changed

@@ -30,7 +30,7 @@
  * ;                                                             ;
  * ;  ,-nicesrc-, ,-capsfilter-, ,---queue---, ,-dtlssrtpdec-,   ;
  * ;  ;     src o-o sink   src o-o sink  src o-osink  rtp_srco---o rtp_src
- * ;  '---------' '------------' '-----------' ;             ;   ; 
+ * ;  '---------' '------------' '-----------' ;             ;   ;
  * ;                                           ;     rtcp_srco---o rtcp_src
  * ;                                           ;             ;   ;
  * ;                                           ;     data_srco---o data_src
@@ -109,18 +109,18 @@
 }
 
 void
-transport_receive_bin_set_receive_state (TransportReceiveBin * receive,
+transport_receive_bin_set_dtls_receive_state (TransportReceiveBin * receive,
     ReceiveState state)
 {
   GstWebRTCICEConnectionState icestate;
 
   g_mutex_lock (&receive->pad_block_lock);
-  if (receive->receive_state != state) {
+  if (receive->dtls_receive_state != state) {
     GST_DEBUG_OBJECT (receive, "Requested change of receive state to %s",
         _receive_state_to_string (state));
   }
 
-  receive->receive_state = state;
+  receive->dtls_receive_state = state;
 
   g_object_get (receive->stream->transport->transport, "state", &icestate,
       NULL);
@@ -138,17 +138,13 @@
   if (state == RECEIVE_STATE_PASS) {
     g_object_set (receive->queue, "leaky", 0, NULL);
 
-    if (receive->rtp_block)
-      _free_pad_block (receive->rtp_block);
-    receive->rtp_block = NULL;
-
-    if (receive->rtcp_block)
-      _free_pad_block (receive->rtcp_block);
-    receive->rtcp_block = NULL;
+    if (receive->input_block)
+      _free_pad_block (receive->input_block);
+    receive->input_block = NULL;
   } else {
     g_assert (state == RECEIVE_STATE_BLOCK);
     g_object_set (receive->queue, "leaky", 2, NULL);
-    if (receive->rtp_block == NULL) {
+    if (receive->input_block == NULL) {
       GstWebRTCDTLSTransport *transport;
       GstElement *dtlssrtpdec;
       GstPad *pad, *peer_pad;
@@ -158,9 +154,9 @@
         dtlssrtpdec = transport->dtlssrtpdec;
         pad = gst_element_get_static_pad (dtlssrtpdec, "sink");
         peer_pad = gst_pad_get_peer (pad);
-        receive->rtp_block =
+        receive->input_block =
             _create_pad_block (GST_ELEMENT (receive), peer_pad, 0, NULL, NULL);
-        receive->rtp_block->block_id =
+        receive->input_block->block_id =
             gst_pad_add_probe (peer_pad,
             GST_PAD_PROBE_TYPE_BLOCK |
             GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM,
@@ -173,11 +169,72 @@
   g_mutex_unlock (&receive->pad_block_lock);
 }
 
+void
+transport_receive_bin_set_data_receive_state (TransportReceiveBin * receive,
+    ReceiveState state)
+{
+  g_mutex_lock (&receive->pad_block_lock);
+  if (receive->data_receive_state != state) {
+    GST_DEBUG_OBJECT (receive, "Requested change of receive state to %s",
+        _receive_state_to_string (state));
+  }
+
+  receive->data_receive_state = state;
+
+  if (state == RECEIVE_STATE_PASS) {
+    if (receive->rtp_block)
+      _free_pad_block (receive->rtp_block);
+    receive->rtp_block = NULL;
+
+    if (receive->rtcp_block)
+      _free_pad_block (receive->rtcp_block);
+    receive->rtcp_block = NULL;
+
+    if (receive->data_block)
+      _free_pad_block (receive->data_block);
+    receive->data_block = NULL;
+  } else {
+    g_assert (state == RECEIVE_STATE_BLOCK);
+
+    if (receive->rtp_block == NULL) {
+      receive->rtp_block =
+          _create_pad_block (GST_ELEMENT (receive), receive->rtp_src, 0, NULL,
+          NULL);
+      receive->rtp_block->block_id =
+          gst_pad_add_probe (receive->rtp_src,
+          GST_PAD_PROBE_TYPE_BLOCK | GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM,
+          (GstPadProbeCallback) pad_block, receive, NULL);
+    }
+
+    if (receive->rtcp_block == NULL) {
+      receive->rtcp_block =
+          _create_pad_block (GST_ELEMENT (receive), receive->rtcp_src, 0, NULL,
+          NULL);
+      receive->rtcp_block->block_id =
+          gst_pad_add_probe (receive->rtcp_src,
+          GST_PAD_PROBE_TYPE_BLOCK | GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM,
+          (GstPadProbeCallback) pad_block, receive, NULL);
+    }
+
+    if (receive->data_block == NULL) {
+      receive->data_block =
+          _create_pad_block (GST_ELEMENT (receive), receive->data_src, 0, NULL,
+          NULL);
+      receive->data_block->block_id =
+          gst_pad_add_probe (receive->data_src,
+          GST_PAD_PROBE_TYPE_BLOCK | GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM,
+          (GstPadProbeCallback) pad_block, receive, NULL);
+    }
+  }
+  g_mutex_unlock (&receive->pad_block_lock);
+}
+
 static void
 _on_notify_ice_connection_state (GstWebRTCICETransport * transport,
     GParamSpec * pspec, TransportReceiveBin * receive)
 {
-  transport_receive_bin_set_receive_state (receive, receive->receive_state);
+  transport_receive_bin_set_dtls_receive_state (receive,
+      receive->dtls_receive_state);
 }
 
 static void
@@ -245,7 +302,10 @@
       /* We want to start blocked, unless someone already switched us
        * to PASS mode. receive_state is set to BLOCKED in _init(),
        * so set up blocks with whatever the mode is now. */
-      transport_receive_bin_set_receive_state (receive, receive->receive_state);
+      transport_receive_bin_set_dtls_receive_state (receive,
+          receive->dtls_receive_state);
+      transport_receive_bin_set_data_receive_state (receive,
+          receive->data_receive_state);
 
       /* XXX: because nice needs the nicesrc internal main loop running in order
        * correctly STUN... */
@@ -271,6 +331,10 @@
       gst_element_set_locked_state (elem, FALSE);
       gst_element_set_state (elem, GST_STATE_NULL);
 
+      if (receive->input_block)
+        _free_pad_block (receive->input_block);
+      receive->input_block = NULL;
+
       if (receive->rtp_block)
         _free_pad_block (receive->rtp_block);
       receive->rtp_block = NULL;
@@ -279,6 +343,10 @@
         _free_pad_block (receive->rtcp_block);
       receive->rtcp_block = NULL;
 
+      if (receive->data_block)
+        _free_pad_block (receive->data_block);
+      receive->data_block = NULL;
+
       break;
     }
     default:
@@ -311,7 +379,7 @@
 {
   TransportReceiveBin *receive = TRANSPORT_RECEIVE_BIN (object);
   GstWebRTCDTLSTransport *transport;
-  GstPad *ghost, *pad;
+  GstPad *pad;
   GstElement *capsfilter;
   GstCaps *caps;
 
@@ -371,8 +439,8 @@
   /* expose data_src */
   pad = gst_element_request_pad_simple (receive->stream->transport->dtlssrtpdec,
       "data_src");
-  ghost = gst_ghost_pad_new ("data_src", pad);
-  gst_element_add_pad (GST_ELEMENT (receive), ghost);
+  receive->data_src = gst_ghost_pad_new ("data_src", pad);
+  gst_element_add_pad (GST_ELEMENT (receive), receive->data_src);
   gst_object_unref (pad);
 
   g_signal_connect_after (receive->stream->transport->transport,
@@ -416,6 +484,7 @@
 static void
 transport_receive_bin_init (TransportReceiveBin * receive)
 {
-  receive->receive_state = RECEIVE_STATE_BLOCK;
+  receive->dtls_receive_state = RECEIVE_STATE_BLOCK;
+  receive->data_receive_state = RECEIVE_STATE_BLOCK;
   g_mutex_init (&receive->pad_block_lock);
 }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/webrtc/transportreceivebin.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/webrtc/transportreceivebin.h Changed

@@ -45,14 +45,17 @@
   TransportStream           *stream;        /* parent transport stream */
 
   GstPad                    *rtp_src;
-  gulong                     rtp_src_probe_id;
   GstPad                    *rtcp_src;
-  gulong                     rtcp_src_probe_id;
+  GstPad                    *data_src;
+  GMutex                     pad_block_lock;
+  ReceiveState               dtls_receive_state;
+  struct pad_block          *input_block;
+  ReceiveState               data_receive_state;
   struct pad_block          *rtp_block;
   struct pad_block          *rtcp_block;
-  GMutex                     pad_block_lock;
-  ReceiveState               receive_state;
+  struct pad_block          *data_block;
   GstElement                *queue;
+  gboolean                   validated_fingerprint;
 };
 
 struct _TransportReceiveBinClass
@@ -60,7 +63,9 @@
   GstBinClass           parent_class;
 };
 
-void        transport_receive_bin_set_receive_state         (TransportReceiveBin * receive,
+void        transport_receive_bin_set_dtls_receive_state    (TransportReceiveBin * receive,
+                                                             ReceiveState state);
+void        transport_receive_bin_set_data_receive_state    (TransportReceiveBin * receive,
                                                              ReceiveState state);
 
 G_END_DECLS

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/webrtc/utils.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/webrtc/utils.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/webrtc/utils.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/webrtc/utils.h Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/webrtc/webrtcsdp.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/webrtc/webrtcsdp.c Changed

@@ -125,8 +125,8 @@
     if (direction == GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE)
       continue;
 
-    if (!IS_EMPTY_SDP_ATTRIBUTE (message_fingerprint)
-        && !IS_EMPTY_SDP_ATTRIBUTE (media_fingerprint)) {
+    if (IS_EMPTY_SDP_ATTRIBUTE (message_fingerprint)
+        && IS_EMPTY_SDP_ATTRIBUTE (media_fingerprint)) {
       g_set_error (error, GST_WEBRTC_ERROR,
           GST_WEBRTC_ERROR_FINGERPRINT_FAILURE,
           "No fingerprint lines in sdp for media %u", i);
@@ -749,6 +749,52 @@
   return g_string_free (fingerprint, FALSE);
 }
 
+static char *
+parse_fingerprint (const char *fingerprint, GChecksumType * checksum)
+{
+  const char *loc = g_strstr_len (fingerprint, -1, " ");
+  if (!loc)
+    return NULL;
+
+  char *checksum_s = g_strndup (fingerprint, loc - fingerprint);
+  GChecksumType our_checksum = _g_checksum_from_webrtc_string (checksum_s);
+  g_clear_pointer (&checksum_s, g_free);
+
+  if (!our_checksum)
+    return NULL;
+
+  if (!loc || loc0 == '\0')
+    return NULL;
+
+  *checksum = our_checksum;
+  return g_strdup (&loc1);
+}
+
+gchar *
+_get_fingerprint_from_sdp_media (GstSDPMessage * sdp, guint media_idx,
+    GChecksumType * checksum_type)
+{
+  {
+    /* search in the corresponding media section */
+    const GstSDPMedia *media = gst_sdp_message_get_media (sdp, media_idx);
+    const gchar *fp = gst_sdp_media_get_attribute_val (media, "fingerprint");
+    if (fp) {
+      return parse_fingerprint (fp, checksum_type);
+    }
+  }
+
+  /* then in the sdp message itself */
+  for (int i = 0; i < gst_sdp_message_attributes_len (sdp); i++) {
+    const GstSDPAttribute *attr = gst_sdp_message_get_attribute (sdp, i);
+
+    if (g_strcmp0 (attr->key, "fingerprint") == 0) {
+      return parse_fingerprint (attr->value, checksum_type);
+    }
+  }
+
+  return NULL;
+}
+
 #define DEFAULT_ICE_UFRAG_LEN 32
 #define DEFAULT_ICE_PASSWORD_LEN 32
 static const gchar *ice_credential_chars =

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/ext/webrtc/webrtcsdp.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/ext/webrtc/webrtcsdp.h Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/codecparsers/gstav1parser.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/codecparsers/gstav1parser.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/codecparsers/gsth266parser.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/codecparsers/gsth266parser.c Changed

@@ -360,7 +360,8 @@
     }
 
     /* skip the reserved zero bits */
-    if (!nal_reader_skip (nr, num_additional_bits - num_additional_bits_used))
+    if (!nal_reader_skip_long (nr,
+            num_additional_bits - num_additional_bits_used))
       goto error;
   }
 
@@ -486,9 +487,13 @@
       READ_UINT16 (nr, vui->sar_height, 16);
       vui->par_n = vui->sar_width;
       vui->par_d = vui->sar_height;
-    } else {
+    } else if (vui->aspect_ratio_idc <= 16) {
       vui->par_n = aspect_ratiosvui->aspect_ratio_idc.par_n;
       vui->par_d = aspect_ratiosvui->aspect_ratio_idc.par_d;
+    } else {
+      GST_WARNING ("Invalid bitstream: aspect_ratio_idc set "
+          "to value %d (must be 0-16 or %d)",
+          vui->aspect_ratio_idc, EXTENDED_SAR);
     }
   } else {
     vui->aspect_ratio_constant_flag = 0;
@@ -2168,30 +2173,39 @@
 GstH266ParserResult
 gst_h266_parser_parse_nal (GstH266Parser * parser, GstH266NalUnit * nalu)
 {
-  GstH266VPS vps;
-  GstH266SPS sps;
-  GstH266PPS pps;
-  GstH266APS aps;
+  GstH266ParserResult res = GST_H266_PARSER_OK;
 
   switch (nalu->type) {
-    case GST_H266_NAL_VPS:
-      return gst_h266_parser_parse_vps (parser, nalu, &vps);
+    case GST_H266_NAL_VPS:{
+      GstH266VPS *vps = g_new (GstH266VPS, 1);
+      res = gst_h266_parser_parse_vps (parser, nalu, vps);
+      g_free (vps);
       break;
-    case GST_H266_NAL_SPS:
-      return gst_h266_parser_parse_sps (parser, nalu, &sps);
+    }
+    case GST_H266_NAL_SPS:{
+      GstH266SPS *sps = g_new (GstH266SPS, 1);
+      res = gst_h266_parser_parse_sps (parser, nalu, sps);
+      g_free (sps);
       break;
-    case GST_H266_NAL_PPS:
-      return gst_h266_parser_parse_pps (parser, nalu, &pps);
+    }
+    case GST_H266_NAL_PPS:{
+      GstH266PPS *pps = g_new (GstH266PPS, 1);
+      res = gst_h266_parser_parse_pps (parser, nalu, pps);
+      g_free (pps);
       break;
+    }
     case GST_H266_NAL_PREFIX_APS:
-    case GST_H266_NAL_SUFFIX_APS:
-      return gst_h266_parser_parse_aps (parser, nalu, &aps);
+    case GST_H266_NAL_SUFFIX_APS:{
+      GstH266APS *aps = g_new (GstH266APS, 1);
+      res = gst_h266_parser_parse_aps (parser, nalu, aps);
+      g_free (aps);
       break;
+    }
     default:
       break;
   }
 
-  return GST_H266_PARSER_OK;
+  return res;
 }
 
 /**
@@ -3760,9 +3774,15 @@
           } else {              /* tile contains multi slices */
             guint16 slice_height_in_ctus;
 
+            if (pps->num_exp_slices_in_tilei > GST_H266_MAX_TILE_ROWS) {
+              GST_WARNING ("Too many exp slices %d",
+                  pps->num_exp_slices_in_tilei);
+              goto error;
+            }
+
             for (j = 0; j < pps->num_exp_slices_in_tilei; j++) {
               if (i + j >= pps->num_slices_in_pic_minus1) {
-                GST_WARNING ("Too may slices %d", i + j + 1);
+                GST_WARNING ("Too many slices %d", i + j + 1);
                 goto error;
               }
 
@@ -3786,7 +3806,7 @@
             /* Assign the remaining CTBs to slices */
             while (remaining_height_in_ctbs_y > uniform_slice_height) {
               if (i + j > pps->num_slices_in_pic_minus1) {
-                GST_WARNING ("Too may slices %d", i + j + 1);
+                GST_WARNING ("Too many slices %d", i + j + 1);
                 goto error;
               }
 
@@ -3802,7 +3822,7 @@
 
             if (remaining_height_in_ctbs_y > 0) {
               if (i + j > pps->num_slices_in_pic_minus1) {
-                GST_WARNING ("Too may slices %d", i + j + 1);
+                GST_WARNING ("Too many slices %d", i + j + 1);
                 goto error;
               }
 
@@ -5972,15 +5992,15 @@
           parser->ctb_to_tile_col_bdpre_ctb_addr_x
           || (ctb_addr_y != pre_ctb_addr_y
               && sps->entropy_coding_sync_enabled_flag)) {
+        if (sh->num_entry_points >= GST_H266_MAX_ENTRY_POINTS) {
+          GST_WARNING ("Too many entry points: %d.", sh->num_entry_points);
+          goto error;
+        }
         sh->entry_point_start_ctush->num_entry_points = i;
         sh->num_entry_points++;
       }
     }
 
-    if (sh->num_entry_points > GST_H266_MAX_ENTRY_POINTS) {
-      GST_WARNING ("Too many entry points: %d.", sh->num_entry_points);
-      goto error;
-    }
     if (sh->num_entry_points > 0) {
       READ_UE_MAX (&nr, sh->entry_offset_len_minus1, 31);
       for (i = 0; i < sh->num_entry_points; i++) {

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/codecparsers/gstvp9parser.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/codecparsers/gstvp9parser.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/codecs/gsth265decoder.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/codecs/gsth265decoder.c Changed

@@ -990,6 +990,18 @@
   GST_LOG_OBJECT (self, "Parsed nal type: %d, offset %d, size %d",
       nalu->type, nalu->offset, nalu->size);
 
+  if (nalu->layer_id != 0) {
+    /* 7.4.2.1
+     * decoders conforming to a profile specified in Annex A and not
+     * supporting the independent non-base layer decoding (INBLD) capability
+     * specified in Annex F shall ignore (i.e., remove from the bitstream
+     * and discard) all NAL units with values of nuh_layer_id not equal to 0
+     */
+    GST_LOG_OBJECT (self, "Skip nalu type %d with layer id %d",
+        nalu->type, nalu->layer_id);
+    return GST_H265_PARSER_OK;
+  }
+
   memset (&decoder_nalu, 0, sizeof (GstH265DecoderNalUnit));
   decoder_nalu.nalu_type = nalu->type;
 
@@ -1181,6 +1193,18 @@
     for (j = 0; j < array->nalu->len; j++) {
       GstH265NalUnit *nalu = &g_array_index (array->nalu, GstH265NalUnit, j);
 
+      if (nalu->layer_id != 0) {
+        /* 7.4.2.1
+         * decoders conforming to a profile specified in Annex A and not
+         * supporting the independent non-base layer decoding (INBLD) capability
+         * specified in Annex F shall ignore (i.e., remove from the bitstream
+         * and discard) all NAL units with values of nuh_layer_id not equal to 0
+         */
+        GST_DEBUG_OBJECT (self, "Skip nalu type %d with layer id %d",
+            nalu->type, nalu->layer_id);
+        continue;
+      }
+
       switch (nalu->type) {
         case GST_H265_NAL_VPS:
           pres = gst_h265_parser_parse_vps (parser, nalu, &vps);

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/d3d12/gstd3d12device.cpp -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/d3d12/gstd3d12device.cpp Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/dxva/gstdxvavp8decoder.cpp -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/dxva/gstdxvavp8decoder.cpp Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/dxva/gstdxvavp9decoder.cpp -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/dxva/gstdxvavp9decoder.cpp Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/mse/meson.build -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/mse/meson.build Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/va/gstvadisplay_drm.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/va/gstvadisplay_drm.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-libs/gst/va/gstvasurfacecopy.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-libs/gst/va/gstvasurfacecopy.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst-plugins-bad.doap -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst-plugins-bad.doap Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/camerabin2/gstwrappercamerabinsrc.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/camerabin2/gstwrappercamerabinsrc.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/closedcaption/ccutils.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/closedcaption/ccutils.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/closedcaption/gstccconverter.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/closedcaption/gstccconverter.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/librfb/rfbdecoder.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/librfb/rfbdecoder.c Changed

@@ -45,6 +45,10 @@
     gint start_y, gint rect_w, gint rect_h);
 static gboolean rfb_decoder_hextile_encoding (RfbDecoder * decoder,
     gint start_x, gint start_y, gint rect_w, gint rect_h);
+static gboolean rfb_decoder_clip_rectangle (RfbDecoder * decoder, gint * x,
+    gint * y, gint * w, gint * h, gint * skip_x, gint * skip_y);
+static gboolean rfb_decoder_clip_copyrect (RfbDecoder * decoder, gint * dst_x,
+    gint * dst_y, gint * src_x, gint * src_y, gint * w, gint * h);
 
 RfbDecoder *
 rfb_decoder_new (void)
@@ -802,23 +806,20 @@
   if (!rfb_decoder_read (decoder, 12))
     return FALSE;
 
-  x = RFB_GET_UINT16 (decoder->data + 0) - decoder->offset_x;
-  y = RFB_GET_UINT16 (decoder->data + 2) - decoder->offset_y;
+  x = RFB_GET_UINT16 (decoder->data + 0);
+  y = RFB_GET_UINT16 (decoder->data + 2);
   w = RFB_GET_UINT16 (decoder->data + 4);
   h = RFB_GET_UINT16 (decoder->data + 6);
   encoding = RFB_GET_UINT32 (decoder->data + 8);
 
+  x -= (gint) decoder->offset_x;
+  y -= (gint) decoder->offset_y;
+
   GST_DEBUG ("update received");
   GST_DEBUG ("x:%d y:%d", x, y);
   GST_DEBUG ("w:%d h:%d", w, h);
   GST_DEBUG ("encoding: %d", encoding);
 
-  if (((w * h) + (x * y)) > (decoder->width * decoder->height)) {
-    GST_ERROR ("Desktop resize is unsupported.");
-    decoder->state = NULL;
-    return TRUE;
-  }
-
   switch (encoding) {
     case ENCODING_TYPE_RAW:
       ret = rfb_decoder_raw_encoding (decoder, x, y, w, h);
@@ -857,11 +858,20 @@
 rfb_decoder_raw_encoding (RfbDecoder * decoder, gint start_x, gint start_y,
     gint rect_w, gint rect_h)
 {
-  gint size;
+  gint copy_x, copy_y, copy_w, copy_h;
+  gint skip_x = 0, skip_y = 0;
+  guint32 size;
   guint8 *frame, *p;
   guint32 raw_line_size;
+  guint32 copy_line_size;
+
+  if (rect_w <= 0 || rect_h <= 0)
+    return TRUE;
 
   raw_line_size = rect_w * decoder->bytespp;
+  if (rect_h > 0 && raw_line_size > G_MAXUINT32 / rect_h)
+    return FALSE;
+
   size = rect_h * raw_line_size;
 
   GST_DEBUG ("Reading %d bytes (%dx%d)", size, rect_w, rect_h);
@@ -869,13 +879,23 @@
   if (!rfb_decoder_read (decoder, size))
     return FALSE;
 
+  copy_x = start_x;
+  copy_y = start_y;
+  copy_w = rect_w;
+  copy_h = rect_h;
+
+  if (!rfb_decoder_clip_rectangle (decoder, &copy_x, &copy_y, &copy_w, &copy_h,
+          &skip_x, &skip_y))
+    return TRUE;
+
   frame =
-      decoder->frame + (((start_y * decoder->rect_width) +
-          start_x) * decoder->bytespp);
-  p = decoder->data;
+      decoder->frame + (((copy_y * decoder->rect_width) +
+          copy_x) * decoder->bytespp);
+  p = decoder->data + (skip_y * raw_line_size) + (skip_x * decoder->bytespp);
+  copy_line_size = copy_w * decoder->bytespp;
 
-  while (rect_h--) {
-    memcpy (frame, p, raw_line_size);
+  while (copy_h--) {
+    memcpy (frame, p, copy_line_size);
     p += raw_line_size;
     frame += decoder->line_size;
   }
@@ -887,7 +907,8 @@
 rfb_decoder_copyrect_encoding (RfbDecoder * decoder, gint start_x, gint start_y,
     gint rect_w, gint rect_h)
 {
-  guint16 src_x, src_y;
+  gint src_x, src_y;
+  gint copy_x, copy_y, copy_w, copy_h;
   gint line_width, copyrect_width;
   guint8 *src, *dst;
 
@@ -895,20 +916,28 @@
     return FALSE;
 
   /* don't forget the offset */
-  src_x = RFB_GET_UINT16 (decoder->data) - decoder->offset_x;
-  src_y = RFB_GET_UINT16 (decoder->data + 2) - decoder->offset_y;
+  src_x = RFB_GET_UINT16 (decoder->data) - (gint) decoder->offset_x;
+  src_y = RFB_GET_UINT16 (decoder->data + 2) - (gint) decoder->offset_y;
   GST_DEBUG ("Copyrect from %d %d", src_x, src_y);
 
-  copyrect_width = rect_w * decoder->bytespp;
+  copy_x = start_x;
+  copy_y = start_y;
+  copy_w = rect_w;
+  copy_h = rect_h;
+  if (!rfb_decoder_clip_copyrect (decoder, &copy_x, &copy_y, &src_x, &src_y,
+          &copy_w, &copy_h))
+    return TRUE;
+
+  copyrect_width = copy_w * decoder->bytespp;
   line_width = decoder->line_size;
   src =
       decoder->prev_frame + ((src_y * decoder->rect_width) +
       src_x) * decoder->bytespp;
   dst =
-      decoder->frame + ((start_y * decoder->rect_width) +
-      start_x) * decoder->bytespp;
+      decoder->frame + ((copy_y * decoder->rect_width) +
+      copy_x) * decoder->bytespp;
 
-  while (rect_h--) {
+  while (copy_h--) {
     memcpy (dst, src, copyrect_width);
     src += line_width;
     dst += line_width;
@@ -923,19 +952,51 @@
 {
   /* fill the whole region with the same color */
 
-  guint32 *offset;
   gint i, j;
 
+  if (!rfb_decoder_clip_rectangle (decoder, &x, &y, &w, &h, NULL, NULL))
+    return;
+
   for (i = 0; i < h; i++) {
-    offset =
-        (guint32 *) (decoder->frame + ((x + (y +
-                    i) * decoder->rect_width)) * decoder->bytespp);
+    guint8 *offset =
+        decoder->frame + ((x + (y +
+                i) * decoder->rect_width)) * decoder->bytespp;
+
     for (j = 0; j < w; j++) {
-      *(offset++) = color;
+      switch (decoder->bytespp) {
+        case 1:
+          *(guint8 *) offset = (guint8) color;
+          break;
+        case 2:
+          *(guint16 *) offset = (guint16) color;
+          break;
+        case 4:
+          *(guint32 *) offset = color;
+          break;
+        default:
+          /* reject unsupported format */
+          return;
+      }
+      offset += decoder->bytespp;
     }
   }
 }
 
+static inline guint32
+rfb_decoder_get_pixel (RfbDecoder * decoder, const guint8 * data)
+{
+  switch (decoder->bytespp) {
+    case 1:
+      return RFB_GET_UINT8 (data);
+    case 2:
+      return GUINT16_SWAP_LE_BE (RFB_GET_UINT16 (data));
+    case 4:
+      return GUINT32_SWAP_LE_BE (RFB_GET_UINT32 (data));
+    default:
+      return 0;
+  }
+}
+
 static gboolean
 rfb_decoder_rre_encoding (RfbDecoder * decoder, gint start_x, gint start_y,
     gint rect_w, gint rect_h)
@@ -947,7 +1008,7 @@
     return FALSE;
 
   number_of_rectangles = RFB_GET_UINT32 (decoder->data);
-  color = GUINT32_SWAP_LE_BE ((RFB_GET_UINT32 (decoder->data + 4)));
+  color = rfb_decoder_get_pixel (decoder, decoder->data + 4);
 
   GST_DEBUG ("number of rectangles :%d", number_of_rectangles);
 
@@ -959,7 +1020,7 @@
     if (!rfb_decoder_read (decoder, decoder->bytespp + 8))
       return FALSE;
 
-    color = GUINT32_SWAP_LE_BE ((RFB_GET_UINT32 (decoder->data)));
+    color = rfb_decoder_get_pixel (decoder, decoder->data);
     x = RFB_GET_UINT16 (decoder->data + decoder->bytespp);
     y = RFB_GET_UINT16 (decoder->data + decoder->bytespp + 2);
     w = RFB_GET_UINT16 (decoder->data + decoder->bytespp + 4);
@@ -983,7 +1044,7 @@
     return FALSE;
 
   number_of_rectangles = RFB_GET_UINT32 (decoder->data);
-  color = GUINT32_SWAP_LE_BE ((RFB_GET_UINT32 (decoder->data + 4)));
+  color = rfb_decoder_get_pixel (decoder, decoder->data + 4);
 
   GST_DEBUG ("number of rectangles :%d", number_of_rectangles);
 
@@ -995,7 +1056,7 @@
     if (!rfb_decoder_read (decoder, decoder->bytespp + 4))
       return FALSE;
 
-    color = GUINT32_SWAP_LE_BE ((RFB_GET_UINT32 (decoder->data)));
+    color = rfb_decoder_get_pixel (decoder, decoder->data);
     x = RFB_GET_UINT8 (decoder->data + decoder->bytespp);
     y = RFB_GET_UINT8 (decoder->data + decoder->bytespp + 1);
     w = RFB_GET_UINT8 (decoder->data + decoder->bytespp + 2);
@@ -1045,7 +1106,7 @@
         if (!rfb_decoder_read (decoder, decoder->bytespp))
           return FALSE;
 
-        background = GUINT32_SWAP_LE_BE ((RFB_GET_UINT32 (decoder->data)));
+        background = rfb_decoder_get_pixel (decoder, decoder->data);
       }
       rfb_decoder_fill_rectangle (decoder, x, y,
           (x <= x_max_16 ? 16 : x_end), (y <= y_max_16 ? 16 : y_end),
@@ -1055,7 +1116,7 @@
         if (!rfb_decoder_read (decoder, decoder->bytespp))
           return FALSE;
 
-        foreground = GUINT32_SWAP_LE_BE ((RFB_GET_UINT32 (decoder->data)));
+        foreground = rfb_decoder_get_pixel (decoder, decoder->data);
       }
 
       if (subencoding & SUBENCODING_ANYSUBRECTS) {
@@ -1074,8 +1135,7 @@
           return FALSE;
 
         while (nr_subrect--) {
-          foreground =
-              GUINT32_SWAP_LE_BE ((RFB_GET_UINT32 (decoder->data + offset)));
+          foreground = rfb_decoder_get_pixel (decoder, decoder->data + offset);
           offset += decoder->bytespp;
           xy = RFB_GET_UINT8 (decoder->data + offset++);
           wh = RFB_GET_UINT8 (decoder->data + offset++);
@@ -1102,6 +1162,68 @@
 }
 
 static gboolean
+rfb_decoder_clip_rectangle (RfbDecoder * decoder, gint * x, gint * y, gint * w,
+    gint * h, gint * skip_x, gint * skip_y)
+{
+  gint x1, y1, x2, y2;
+  gint orig_x, orig_y;
+
+  if (*w <= 0 || *h <= 0)
+    return FALSE;
+
+  orig_x = *x;
+  orig_y = *y;
+  x1 = MAX (orig_x, 0);
+  y1 = MAX (orig_y, 0);
+  x2 = MIN (orig_x + *w, (gint) decoder->rect_width);
+  y2 = MIN (orig_y + *h, (gint) decoder->rect_height);
+
+  if (x2 <= x1 || y2 <= y1)
+    return FALSE;
+
+  *x = x1;
+  *y = y1;
+  *w = x2 - x1;
+  *h = y2 - y1;
+
+  if (skip_x)
+    *skip_x = x1 - orig_x;
+  if (skip_y)
+    *skip_y = y1 - orig_y;
+
+  return TRUE;
+}
+
+static gboolean
+rfb_decoder_clip_copyrect (RfbDecoder * decoder, gint * dst_x, gint * dst_y,
+    gint * src_x, gint * src_y, gint * w, gint * h)
+{
+  gint left, top, right, bottom;
+
+  if (*w <= 0 || *h <= 0)
+    return FALSE;
+
+  left = MAX (0, MAX (-*dst_x, -*src_x));
+  top = MAX (0, MAX (-*dst_y, -*src_y));
+  right = MIN (*w, MIN ((gint) decoder->rect_width - *dst_x,
+          (gint) decoder->rect_width - *src_x));
+  bottom = MIN (*h, MIN ((gint) decoder->rect_height - *dst_y,
+          (gint) decoder->rect_height - *src_y));
+
+  if (right <= left || bottom <= top)
+    return FALSE;
+
+  *dst_x += left;
+  *dst_y += top;
+  *src_x += left;
+  *src_y += top;
+  *w = right - left;
+  *h = bottom - top;
+
+  return TRUE;
+}
+
+static gboolean
 rfb_decoder_state_set_colour_map_entries (RfbDecoder * decoder)
 {
   g_critical ("not implemented");

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mpegdemux/gstmpegdemux.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mpegdemux/gstmpegdemux.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mpegtsdemux/mpegtspacketizer.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mpegtsdemux/mpegtspacketizer.c Changed

@@ -2292,21 +2292,48 @@
   pcrtable = get_pcr_table (packetizer, pcr_pid);
 
   if (pcr_pid == 0x1fff && GST_CLOCK_TIME_IS_VALID (packetizer->last_in_time)) {
+    /* pcr_pid = 0x1fff means no PCR table, so figure things out from PTSes */
     if (!GST_CLOCK_TIME_IS_VALID (pcrtable->base_time)) {
+      /* Take the first base time we see as a reference */
       pcrtable->base_time = packetizer->last_in_time;
       pcrtable->base_pcrtime = pts;
     } else if (check_diff) {
-      /* Handle discont and wraparound */
+      /* Handle discont and wraparound:
+       * The wraparound handling code assumes that the PCR gets updated regularly for
+       * being able to detect wraparounds. With ignore-pcr=true, or with no PCR track,
+       * that is not the case and it would stay initialized at 1h forever.
+       * 
+       * To avoid this problem, update the fake PCR whenever the PTS advanced by more
+       * than 5s, and also detect wraparounds in these fake PCRs.
+       */
       guint64 tmp_pts = pts + pcrtable->pcroffset + packetizer->extra_shift;
-      if (pcrtable->base_pcrtime < tmp_pts
-          && tmp_pts - pcrtable->base_pcrtime >= 5 * GST_SECOND) {
+      gint64 pcr_pts_diff = tmp_pts - pcrtable->base_pcrtime;
+
+      if (pcrtable->base_pcrtime < tmp_pts &&
+          pcr_pts_diff >= 5 * GST_SECOND &&
+          pcr_pts_diff < PCR_GST_MAX_VALUE / 2 /* Ignore wrap-under */ ) {
         guint64 diff = tmp_pts - pcrtable->base_pcrtime - 2 * GST_SECOND;
 
         pcrtable->base_time += diff;
         pcrtable->base_pcrtime += diff;
+        GST_DEBUG ("base_pcrtime now %" GST_TIMEP_FORMAT " to catch up to PTS %"
+            GST_TIMEP_FORMAT, &pcrtable->base_pcrtime, &tmp_pts);
       } else if (pcrtable->base_pcrtime > tmp_pts
           && pcrtable->base_pcrtime - tmp_pts > PCR_GST_MAX_VALUE / 2) {
+        GST_DEBUG ("Incrementing PCR offset for wraparound. base_pcrtime %"
+            GST_TIMEP_FORMAT " adjusted PTS %" GST_TIMEP_FORMAT,
+            &pcrtable->base_pcrtime, &tmp_pts);
         pcrtable->pcroffset += PCR_GST_MAX_VALUE;
+      } else if (pcrtable->base_pcrtime < tmp_pts
+          && tmp_pts - pcrtable->base_pcrtime > PCR_GST_MAX_VALUE / 2) {
+        /* This can happen when we get an out-of-order PTS that steps backward to before the
+         * previous rollover. The epoch can flip-flop a bit as we cross over, but settles
+         * once every stream advances enough */
+        GST_DEBUG
+            ("Decrementing PCR offset for backward PTS step. base_pcrtime %"
+            GST_TIMEP_FORMAT " adjusted PTS %" GST_TIMEP_FORMAT,
+            &pcrtable->base_pcrtime, &tmp_pts);
+        pcrtable->pcroffset -= PCR_GST_MAX_VALUE;
       }
     }
   }
@@ -2554,7 +2581,9 @@
       lastpcr, lastoffset);
 
   res = firstoffset;
-  if (lastpcr != firstpcr)
+  if (querypcr < firstpcr)
+    querypcr = firstpcr;
+  else if (lastpcr != firstpcr)
     res += gst_util_uint64_scale (querypcr - firstpcr,
         lastoffset - firstoffset, lastpcr - firstpcr);

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mpegtsmux/tsmux/tsmux.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mpegtsmux/tsmux/tsmux.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mxf/mxfdemux.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mxf/mxfdemux.c Changed

@@ -465,7 +465,7 @@
 
     if (!cand->source_package->is_interleaved) {
       GST_DEBUG_OBJECT (demux,
-          "Assigning single track %d (0x%08x) to partition at offset %"
+          "Assigning single track %u (0x%08x) to partition at offset %"
           G_GUINT64_FORMAT, cand->track_id, cand->track_number,
           partition->partition.this_partition);
 
@@ -586,7 +586,7 @@
 
 out:
   GST_DEBUG_OBJECT (demux,
-      "Current partition now %p (body_sid:%d index_sid:%d this_partition:%"
+      "Current partition now %p (body_sid:%u index_sid:%u this_partition:%"
       G_GUINT64_FORMAT ")", p, p->partition.body_sid, p->partition.index_sid,
       p->partition.this_partition);
   demux->current_partition = p;
@@ -859,7 +859,7 @@
       track = MXF_METADATA_TIMELINE_TRACK (package->parent.tracksj);
       if ((track->parent.type & 0xf0) != 0x30) {
         GST_DEBUG_OBJECT (demux,
-            "Skipping track of type 0x%02x (id:%d number:0x%08x)",
+            "Skipping track of type 0x%02x (id:%u number:0x%08x)",
             track->parent.type, track->parent.track_id,
             track->parent.track_number);
         continue;
@@ -925,6 +925,7 @@
         tmp->track_number = track->parent.track_number;
         tmp->track_id = track->parent.track_id;
         memcpy (&tmp->source_package_uid, &package->parent.package_uid, 32);
+        tmp->offsets = g_array_new (FALSE, TRUE, sizeof (GstMXFDemuxIndex));
 
         if (demux->current_partition->partition.body_sid == edata->body_sid &&
             demux->current_partition->partition.body_offset == 0)
@@ -1065,7 +1066,7 @@
 
       if (package->is_interleaved) {
         GST_DEBUG_OBJECT (demux,
-            "track comes from interleaved source package with %d track(s), setting delta_id to -1",
+            "track comes from interleaved source package with %u track(s), setting delta_id to -1",
             package->parent.n_tracks);
         if (etrack->wrapping != MXF_ESSENCE_WRAPPING_FRAME_WRAPPING) {
           GST_ELEMENT_ERROR (demux, STREAM, WRONG_TYPE, (NULL),
@@ -1145,11 +1146,11 @@
       GST_DEBUG_OBJECT (demux, "Unknown package type");
   }
 
-  GST_DEBUG_OBJECT (demux, "Number of Material Package (i.e. output) : %d",
+  GST_DEBUG_OBJECT (demux, "Number of Material Package (i.e. output) : %u",
       g_list_length (material_packages));
   for (tmp = material_packages; tmp; tmp = tmp->next) {
     MXFMetadataMaterialPackage *pack = (MXFMetadataMaterialPackage *) tmp->data;
-    GST_DEBUG_OBJECT (demux, "  Package with %d tracks , UID:%s",
+    GST_DEBUG_OBJECT (demux, "  Package with %u tracks , UID:%s",
         pack->n_tracks, mxf_umid_to_string (&pack->package_uid, str));
     for (i = 0; i < pack->n_tracks; i++) {
       MXFMetadataTrack *track = pack->tracksi;
@@ -1159,33 +1160,33 @@
       } else if (MXF_IS_METADATA_TIMELINE_TRACK (track)) {
         MXFMetadataTimelineTrack *mtrack = (MXFMetadataTimelineTrack *) track;
         GST_DEBUG_OBJECT (demux,
-            "    Timeline Track id:%d number:0x%08x name:`%s` edit_rate:%d/%d origin:%"
-            G_GINT64_FORMAT, track->track_id, track->track_number,
+            "    Timeline Track id:%u number:0x%08x name:`%s` edit_rate:%d/%d origin:%"
+            G_GUINT64_FORMAT, track->track_id, track->track_number,
             track->track_name, mtrack->edit_rate.n, mtrack->edit_rate.d,
             mtrack->origin);
       } else {
         GST_DEBUG_OBJECT (demux,
-            "    Non-Timeline-Track id:%d number:0x%08x name:`%s`",
+            "    Non-Timeline-Track id:%u number:0x%08x name:`%s`",
             track->track_id, track->track_number, track->track_name);
       }
       if (track) {
         MXFMetadataSequence *sequence = track->sequence;
         guint si;
         GST_DEBUG_OBJECT (demux,
-            "      Sequence duration:%" G_GINT64_FORMAT
-            " n_structural_components:%d", sequence->duration,
+            "      Sequence duration:%" G_GUINT64_FORMAT
+            " n_structural_components:%u", sequence->duration,
             sequence->n_structural_components);
         for (si = 0; si < sequence->n_structural_components; si++) {
           MXFMetadataStructuralComponent *comp =
               sequence->structural_componentssi;
           GST_DEBUG_OBJECT (demux,
-              "        Component #%d duration:%" G_GINT64_FORMAT, si,
+              "        Component #%u duration:%" G_GUINT64_FORMAT, si,
               comp->duration);
           if (MXF_IS_METADATA_SOURCE_CLIP (comp)) {
             MXFMetadataSourceClip *clip = (MXFMetadataSourceClip *) comp;
             GST_DEBUG_OBJECT (demux,
-                "          Clip start_position:%" G_GINT64_FORMAT
-                " source_track_id:%d source_package_id:%s",
+                "          Clip start_position:%" G_GUINT64_FORMAT
+                " source_track_id:%u source_package_id:%s",
                 clip->start_position, clip->source_track_id,
                 mxf_umid_to_string (&clip->source_package_id, str));
           }
@@ -1195,7 +1196,7 @@
     }
   }
 
-  GST_DEBUG_OBJECT (demux, "Number of File Packages (i.e. input) : %d",
+  GST_DEBUG_OBJECT (demux, "Number of File Packages (i.e. input) : %u",
       g_list_length (file_packages));
   for (tmp = file_packages; tmp; tmp = tmp->next) {
     MXFMetadataMaterialPackage *pack = (MXFMetadataMaterialPackage *) tmp->data;
@@ -1204,7 +1205,7 @@
     MXFMetadataEssenceContainerData *econt =
         essence_container_for_source_package (storage, src);
     GST_DEBUG_OBJECT (demux,
-        "  Package (body_sid:%d index_sid:%d top_level:%d) with %d tracks , UID:%s",
+        "  Package (body_sid:%u index_sid:%u top_level:%u) with %u tracks , UID:%s",
         econt ? econt->body_sid : 0, econt ? econt->index_sid : 0,
         src->top_level, pack->n_tracks, mxf_umid_to_string (&pack->package_uid,
             str));
@@ -1220,13 +1221,13 @@
       if (MXF_IS_METADATA_TIMELINE_TRACK (track)) {
         MXFMetadataTimelineTrack *mtrack = (MXFMetadataTimelineTrack *) track;
         GST_DEBUG_OBJECT (demux,
-            "    Timeline Track id:%d number:0x%08x name:`%s` edit_rate:%d/%d origin:%"
-            G_GINT64_FORMAT, track->track_id, track->track_number,
+            "    Timeline Track id:%u number:0x%08x name:`%s` edit_rate:%d/%d origin:%"
+            G_GUINT64_FORMAT, track->track_id, track->track_number,
             track->track_name, mtrack->edit_rate.n, mtrack->edit_rate.d,
             mtrack->origin);
       } else {
         GST_DEBUG_OBJECT (demux,
-            "    Non-Timeline-Track id:%d number:0x%08x name:`%s` type:0x%x",
+            "    Non-Timeline-Track id:%u number:0x%08x name:`%s` type:0x%x",
             track->track_id, track->track_number, track->track_name,
             track->type);
       }
@@ -1249,14 +1250,14 @@
         }
       }
       GST_DEBUG_OBJECT (demux,
-          "      Sequence duration:%" G_GINT64_FORMAT
-          " n_structural_components:%d", sequence->duration,
+          "      Sequence duration:%" G_GUINT64_FORMAT
+          " n_structural_components:%u", sequence->duration,
           sequence->n_structural_components);
       for (si = 0; si < sequence->n_structural_components; si++) {
         MXFMetadataStructuralComponent *comp =
             sequence->structural_componentssi;
         GST_DEBUG_OBJECT (demux,
-            "        Component #%d duration:%" G_GINT64_FORMAT, si,
+            "        Component #%u duration:%" G_GUINT64_FORMAT, si,
             comp->duration);
       }
     }
@@ -1456,7 +1457,7 @@
 
     if (track->parent.type && (track->parent.type & 0xf0) != 0x30) {
       GST_DEBUG_OBJECT (demux,
-          "No essence track. type:0x%02x track_id:%d track_number:0x%08x",
+          "No essence track. type:0x%02x track_id:%u track_number:0x%08x",
           track->parent.type, track->parent.track_id,
           track->parent.track_number);
       if (!pad) {
@@ -1584,10 +1585,7 @@
       pad->current_component_start = source_track->origin;
       pad->current_component_start_position = 0;
 
-      if (component->parent.duration >= -1)
-        pad->current_component_duration = component->parent.duration;
-      else
-        pad->current_component_duration = -1;
+      pad->current_component_duration = component->parent.duration;
 
       if (track->edit_rate.n != source_track->edit_rate.n ||
           track->edit_rate.d != source_track->edit_rate.d) {
@@ -2006,10 +2004,7 @@
         parent.duration;
   }
 
-  if (pad->current_component->parent.duration >= -1)
-    pad->current_component_duration = pad->current_component->parent.duration;
-  else
-    pad->current_component_duration = -1;
+  pad->current_component_duration = pad->current_component->parent.duration;
 
   if (pad->material_track->edit_rate.n != source_track->edit_rate.n ||
       pad->material_track->edit_rate.d != source_track->edit_rate.d) {
@@ -2104,7 +2099,7 @@
     if (in_partition >= partition_essence_size) {
       GST_WARNING_OBJECT (demux,
           "stream_offset %" G_GUINT64_FORMAT
-          " in track body_sid:% index_sid:%d leaks into next unrelated partition (body_sid:%d / index_sid:%d)",
+          " in track body_sid:% index_sid:%u leaks into next unrelated partition (body_sid:%u / index_sid:%u)",
           stream_offset, etrack->body_sid, etrack->index_sid,
           next_partition->partition.body_sid,
           next_partition->partition.index_sid);
@@ -2149,27 +2144,28 @@
 }
 
 static guint64
-find_offset (GArray * offsets, gint64 * position, gboolean keyframe)
+find_offset (GArray * offsets, guint64 * position, gboolean keyframe)
 {
   GstMXFDemuxIndex *idx;
   guint64 current_offset = -1;
-  gint64 current_position = *position;
+  guint64 current_position = *position;
 
   if (!offsets || offsets->len <= *position)
     return -1;
 
   idx = &g_array_index (offsets, GstMXFDemuxIndex, *position);
-  if (idx->offset != 0 && (!keyframe || idx->keyframe)) {
+  if (idx->initialized && (!keyframe || idx->keyframe)) {
     current_offset = idx->offset;
-  } else if (idx->offset != 0) {
+  } else if (keyframe && current_position > 0) {
     current_position--;
-    while (current_position >= 0) {
-      GST_LOG ("current_position %" G_GINT64_FORMAT, current_position);
+    while (TRUE) {
+      GST_LOG ("current_position %" G_GUINT64_FORMAT, current_position);
       idx = &g_array_index (offsets, GstMXFDemuxIndex, current_position);
-      if (idx->offset == 0) {
-        GST_LOG ("breaking offset 0");
-        break;
-      } else if (!idx->keyframe) {
+      if (!idx->initialized) {
+        /* don't search for a keyframe in an uninitialized gap */
+        GST_LOG ("breaking on uninitialized offset");
+        return -1;
+      } else if (!idx->keyframe && current_position > 0) {
         current_position--;
         continue;
       } else {
@@ -2187,6 +2183,40 @@
   return current_offset;
 }
 
+static void
+have_new_essence_track_index_entry (GstMXFDemux * demux,
+    GstMXFDemuxEssenceTrack * etrack, guint64 position,
+    GstMXFDemuxIndex * entry)
+{
+  if (etrack->offsets->len > position) {
+    GstMXFDemuxIndex *cur_entry =
+        &g_array_index (etrack->offsets, GstMXFDemuxIndex, position);
+    if (cur_entry->initialized) {
+      GST_TRACE_OBJECT (demux,
+          "track %u body_sid:%u index_sid:%u delta_id:%d found initialized entry at position:%"
+          G_GUINT64_FORMAT, etrack->track_id, etrack->body_sid,
+          etrack->index_sid, etrack->delta_id, position);
+
+      return;
+    }
+
+    GST_LOG_OBJECT (demux,
+        "track %u body_sid:%u index_sid:%u delta_id:%d initializing entry at position:%"
+        G_GUINT64_FORMAT, etrack->track_id, etrack->body_sid,
+        etrack->index_sid, etrack->delta_id, position);
+    *cur_entry = *entry;
+
+    return;
+  }
+
+  GST_LOG_OBJECT (demux,
+      "track %u body_sid:%u index_sid:%u delta_id:%d appending entry at position:%"
+      G_GUINT64_FORMAT, etrack->track_id, etrack->body_sid,
+      etrack->index_sid, etrack->delta_id, position);
+
+  g_array_insert_val (etrack->offsets, position, *entry);
+}
+
 /**
  * find_edit_entry:
  * @demux: The demuxer
@@ -2213,7 +2243,7 @@
  */
 static gboolean
 find_edit_entry (GstMXFDemux * demux, GstMXFDemuxEssenceTrack * etrack,
-    gint64 position, gboolean keyframe, GstMXFDemuxIndex * entry)
+    guint64 position, gboolean keyframe, GstMXFDemuxIndex * entry)
 {
   GstMXFDemuxIndexTable *index_table = NULL;
   guint i;
@@ -2222,37 +2252,36 @@
   guint64 stream_offset = G_MAXUINT64, absolute_offset;
 
   GST_DEBUG_OBJECT (demux,
-      "track %d body_sid:%d index_sid:%d delta_id:%d position:%" G_GINT64_FORMAT
-      " keyframe:%d", etrack->track_id, etrack->body_sid,
+      "track %u body_sid:%u index_sid:%u delta_id:%d position:%"
+      G_GUINT64_FORMAT " keyframe:%d", etrack->track_id, etrack->body_sid,
       etrack->index_sid, etrack->delta_id, position, keyframe);
 
+  /* Look in the track offsets */
+  if (find_offset (etrack->offsets, &position, keyframe) != -1) {
+    *entry = g_array_index (etrack->offsets, GstMXFDemuxIndex, position);
+    GST_LOG_OBJECT (demux, "Found entry in track offsets");
+    return TRUE;
+  } else {
+    GST_LOG_OBJECT (demux, "Didn't find entry in track offsets");
+  }
+
   /* Default values */
   entry->duration = 1;
   /* By default every entry is a keyframe unless specified otherwise */
   entry->keyframe = TRUE;
 
-  /* Look in the track offsets */
-  if (etrack->offsets && etrack->offsets->len > position) {
-    if (find_offset (etrack->offsets, &position, keyframe) != -1) {
-      *entry = g_array_index (etrack->offsets, GstMXFDemuxIndex, position);
-      GST_LOG_OBJECT (demux, "Found entry in track offsets");
-      return TRUE;
-    } else
-      GST_LOG_OBJECT (demux, "Didn't find entry in track offsets");
-  }
-
   /* Look in the indextables */
   index_table = get_track_index_table (demux, etrack);
 
   if (!index_table) {
     GST_DEBUG_OBJECT (demux,
-        "Couldn't find index table for body_sid:%d index_sid:%d",
+        "Couldn't find index table for body_sid:%u index_sid:%u",
         etrack->body_sid, etrack->index_sid);
     return FALSE;
   }
 
   GST_DEBUG_OBJECT (demux,
-      "Looking for position %" G_GINT64_FORMAT
+      "Looking for position %" G_GUINT64_FORMAT
       " in index table (max temporal offset %u)",
       etrack->position, index_table->max_temporal_offset);
 
@@ -2267,7 +2296,7 @@
 search_in_segment:
 
   /* Find matching index segment */
-  GST_DEBUG_OBJECT (demux, "Look for entry in %d segments",
+  GST_DEBUG_OBJECT (demux, "Look for entry in %u segments",
       index_table->segments->len);
   for (i = 0; i < index_table->segments->len; i++) {
     MXFIndexTableSegment *cand =
@@ -2276,15 +2305,16 @@
             || position <
             (cand->index_start_position + cand->index_duration))) {
       GST_DEBUG_OBJECT (demux,
-          "Entry is in Segment #%d , start: %" G_GINT64_FORMAT " , duration: %"
-          G_GINT64_FORMAT, i, cand->index_start_position, cand->index_duration);
+          "Entry is in Segment #%u , start: %" G_GUINT64_FORMAT " , duration: %"
+          G_GUINT64_FORMAT, i, cand->index_start_position,
+          cand->index_duration);
       segment = cand;
       break;
     }
   }
   if (!segment) {
     GST_DEBUG_OBJECT (demux,
-        "Didn't find index table segment for position %" G_GINT64_FORMAT,
+        "Didn't find index table segment for position %" G_GUINT64_FORMAT,
         position);
     return FALSE;
   }
@@ -2295,7 +2325,7 @@
       GST_LOG_OBJECT (demux,
           "Index table without entries, directly using requested position for keyframe search");
     } else {
-      gint64 candidate;
+      guint64 candidate;
       GST_LOG_OBJECT (demux, "keyframe search");
       /* Search backwards for keyframe */
       for (candidate = position; candidate >= segment->index_start_position;
@@ -2305,8 +2335,8 @@
 
         /* Match */
         if (segment_index_entry->flags & 0x80) {
-          GST_LOG_OBJECT (demux, "Found keyframe at position %" G_GINT64_FORMAT,
-              candidate);
+          GST_LOG_OBJECT (demux,
+              "Found keyframe at position %" G_GUINT64_FORMAT, candidate);
           position = candidate;
           break;
         }
@@ -2335,7 +2365,7 @@
         /* If we looped past the beginning of this segment, go to the previous one */
         if (candidate == segment->index_start_position) {
           position = candidate - 1;
-          GST_LOG_OBJECT (demux, "Looping with new position %" G_GINT64_FORMAT,
+          GST_LOG_OBJECT (demux, "Looping with new position %" G_GUINT64_FORMAT,
               position);
           goto search_in_segment;
         }
@@ -2366,9 +2396,9 @@
 
       if (entry->size > G_MAXUINT32) {
         GST_ERROR_OBJECT (demux,
-            "Suspisciously large entry size %" G_GINT64_FORMAT
+            "Suspisciously large entry size %" G_GUINT64_FORMAT
             " = edit_unit_byte_count %" G_GUINT32_FORMAT " * entry duration %"
-            G_GINT64_FORMAT ", exceeds pullable size => not proceeding",
+            G_GUINT64_FORMAT ", exceeds pullable size => not proceeding",
             entry->size, segment->edit_unit_byte_count, entry->duration);
         entry = NULL;
         return FALSE;
@@ -2412,15 +2442,15 @@
         entry->pts = position + segment_index_entry->temporal_offset;
       } else if (position >= index_table->reverse_temporal_offsets->len) {
         GST_WARNING_OBJECT (demux,
-            "Can't apply temporal offset for position %" G_GINT64_FORMAT
-            " (max:%d)", position, index_table->reverse_temporal_offsets->len);
+            "Can't apply temporal offset for position %" G_GUINT64_FORMAT
+            " (max:%u)", position, index_table->reverse_temporal_offsets->len);
       } else {
         entry->pts =
             position + g_array_index (index_table->reverse_temporal_offsets,
             gint8, position);
         GST_LOG_OBJECT (demux,
-            "Applied temporal offset. dts:%" G_GINT64_FORMAT " pts:%"
-            G_GINT64_FORMAT, position, entry->pts);
+            "Applied temporal offset. dts:%" G_GUINT64_FORMAT " pts:%"
+            G_GUINT64_FORMAT, position, entry->pts);
       }
     } else
       entry->pts = position;
@@ -2452,13 +2482,15 @@
       offset_partition->partition.body_offset);
 
   GST_LOG_OBJECT (demux,
-      "track %d position:%" G_GINT64_FORMAT " stream_offset %" G_GUINT64_FORMAT
+      "track %u position:%" G_GUINT64_FORMAT " stream_offset %" G_GUINT64_FORMAT
       " matches to absolute offset %" G_GUINT64_FORMAT, etrack->track_id,
       position, stream_offset, absolute_offset);
   entry->initialized = TRUE;
   entry->offset = absolute_offset;
   entry->dts = position;
 
+  have_new_essence_track_index_entry (demux, etrack, position, entry);
+
   return TRUE;
 }
 
@@ -2488,10 +2520,10 @@
   guint64 cp_offset = 0;        /* Offset in Content Package */
   MXFIndexEntry *index_entry = NULL;
   MXFDeltaEntry *delta_entry = NULL;
-  gint64 position = 0;
+  guint64 position = 0;
 
   GST_DEBUG_OBJECT (demux,
-      "track %d body_sid:%d index_sid:%d offset:%" G_GUINT64_FORMAT,
+      "track %u body_sid:%u index_sid:%u offset:%" G_GUINT64_FORMAT,
       etrack->track_id, etrack->body_sid, etrack->index_sid, offset);
 
   /* Default value */
@@ -2499,17 +2531,16 @@
   retentry->keyframe = TRUE;
 
   /* Index-less search */
-  if (etrack->offsets) {
-    for (i = 0; i < etrack->offsets->len; i++) {
-      GstMXFDemuxIndex *idx =
-          &g_array_index (etrack->offsets, GstMXFDemuxIndex, i);
-
-      if (idx->initialized && idx->offset != 0 && idx->offset == offset) {
-        *retentry = *idx;
-        GST_DEBUG_OBJECT (demux,
-            "Found in track index. Position:%" G_GINT64_FORMAT, idx->dts);
-        return TRUE;
-      }
+  for (i = 0; i < etrack->offsets->len; i++) {
+    GstMXFDemuxIndex *idx =
+        &g_array_index (etrack->offsets, GstMXFDemuxIndex, i);
+
+    if (idx->initialized && idx->offset == offset) {
+      g_assert (offset != 0);
+      *retentry = *idx;
+      GST_DEBUG_OBJECT (demux,
+          "Found in track offsets. Position:%" G_GUINT64_FORMAT, idx->dts);
+      return TRUE;
     }
   }
 
@@ -2535,8 +2566,8 @@
   /* Convert to stream offset */
   GST_LOG_OBJECT (demux,
       "offset %" G_GUINT64_FORMAT " this_partition:%" G_GUINT64_FORMAT
-      " essence_container_offset:%" G_GINT64_FORMAT " partition body offset %"
-      G_GINT64_FORMAT, offset, partition->partition.this_partition,
+      " essence_container_offset:%" G_GUINT64_FORMAT " partition body offset %"
+      G_GUINT64_FORMAT, offset, partition->partition.this_partition,
       partition->essence_container_offset, partition->partition.body_offset);
   offset =
       offset - partition->partition.this_partition -
@@ -2550,7 +2581,7 @@
     index_segment =
         &g_array_index (index_table->segments, MXFIndexTableSegment, i - 1);
     GST_DEBUG_OBJECT (demux,
-        "Checking segment #%d (essence_offset %" G_GUINT64_FORMAT ")", i - 1,
+        "Checking segment #%u (essence_offset %" G_GUINT64_FORMAT ")", i - 1,
         index_segment->segment_start_offset);
     /* Not in the right segment yet */
     if (offset >= index_segment->segment_start_offset) {
@@ -2590,9 +2621,9 @@
 
       if (retentry->size > G_MAXUINT32) {
         GST_ERROR_OBJECT (demux,
-            "Suspisciously large entry size %" G_GINT64_FORMAT
+            "Suspisciously large entry size %" G_GUINT64_FORMAT
             " = edit_unit_byte_count %" G_GUINT32_FORMAT " * entry duration %"
-            G_GINT64_FORMAT ", exceeds pullable size => not proceeding",
+            G_GUINT64_FORMAT ", exceeds pullable size => not proceeding",
             retentry->size, index_segment->edit_unit_byte_count,
             retentry->duration);
         retentry = NULL;
@@ -2646,11 +2677,11 @@
       for (delta = 0; delta < index_segment->n_delta_entries; delta++) {
         /* No entry, therefore no slices */
         GST_LOG_OBJECT (demux,
-            "delta #%d offset %" G_GUINT64_FORMAT " cp_offs:%" G_GUINT64_FORMAT
+            "delta #%u offset %" G_GUINT64_FORMAT " cp_offs:%" G_GUINT64_FORMAT
             " element_delta:%u", delta, offset, cp_offset,
             index_segment->delta_entriesdelta.element_delta);
         if (cp_offset == index_segment->delta_entriesdelta.element_delta) {
-          GST_DEBUG_OBJECT (demux, "Matched to delta %d", delta);
+          GST_DEBUG_OBJECT (demux, "Matched to delta %u", delta);
           etrack->delta_id = delta;
           delta_entry = &index_segment->delta_entriesdelta;
           break;
@@ -2667,7 +2698,7 @@
         /* Add the offset for this delta */
         delta_offs += index_segment->delta_entriesdelta.element_delta;
         if (cp_offset == delta_offs) {
-          GST_DEBUG_OBJECT (demux, "Matched to delta %d", delta);
+          GST_DEBUG_OBJECT (demux, "Matched to delta %u", delta);
           etrack->delta_id = delta;
           delta_entry = &index_segment->delta_entriesdelta;
           break;
@@ -2691,26 +2722,28 @@
       retentry->pts = position + index_entry->temporal_offset;
     } else if (position >= index_table->reverse_temporal_offsets->len) {
       GST_WARNING_OBJECT (demux,
-          "Can't apply temporal offset for position %" G_GINT64_FORMAT
-          " (max:%d)", position, index_table->reverse_temporal_offsets->len);
+          "Can't apply temporal offset for position %" G_GUINT64_FORMAT
+          " (max:%u)", position, index_table->reverse_temporal_offsets->len);
     } else {
       retentry->pts =
           position + g_array_index (index_table->reverse_temporal_offsets,
           gint8, position);
     }
     GST_LOG_OBJECT (demux,
-        "Applied temporal offset. dts:%" G_GINT64_FORMAT " pts:%"
-        G_GINT64_FORMAT, position, retentry->pts);
+        "Applied temporal offset. dts:%" G_GUINT64_FORMAT " pts:%"
+        G_GUINT64_FORMAT, position, retentry->pts);
   } else
     retentry->pts = position;
 
   /* FIXME : check if position and cp_offs matches the table */
-  GST_LOG_OBJECT (demux, "Found in index table. position:%" G_GINT64_FORMAT,
+  GST_LOG_OBJECT (demux, "Found in index table. position:%" G_GUINT64_FORMAT,
       position);
   retentry->initialized = TRUE;
   retentry->offset = original_offset;
   retentry->dts = position;
 
+  have_new_essence_track_index_entry (demux, etrack, position, retentry);
+
   return TRUE;
 }
 
@@ -2796,8 +2829,8 @@
   }
 
   GST_DEBUG_OBJECT (demux,
-      "Handling generic container essence (track %d , position:%"
-      G_GINT64_FORMAT ", number: 0x%08x , frame-wrapped:%d)", etrack->track_id,
+      "Handling generic container essence (track %u , position:%"
+      G_GUINT64_FORMAT ", number: 0x%08x , frame-wrapped:%d)", etrack->track_id,
       etrack->position, track_number,
       etrack->wrapping == MXF_ESSENCE_WRAPPING_FRAME_WRAPPING);
 
@@ -2834,8 +2867,8 @@
       GST_WARNING_OBJECT (demux, "Essence track position not in index");
     } else if (etrack->position != index_entry.dts) {
       GST_ERROR_OBJECT (demux,
-          "track position doesn't match %" G_GINT64_FORMAT " entry dts %"
-          G_GINT64_FORMAT, etrack->position, index_entry.dts);
+          "track position doesn't match %" G_GUINT64_FORMAT " entry dts %"
+          G_GUINT64_FORMAT, etrack->position, index_entry.dts);
       return GST_FLOW_ERROR;
     }
   } else {
@@ -2845,14 +2878,14 @@
       if (etrack->delta_id != MXF_INDEX_DELTA_ID_IGNORE
           && index_entry.offset != offset) {
         GST_ERROR_OBJECT (demux,
-            "demux offset doesn't match %" G_GINT64_FORMAT " entry offset %"
+            "demux offset doesn't match %" G_GUINT64_FORMAT " entry offset %"
             G_GUINT64_FORMAT, offset, index_entry.offset);
         return GST_FLOW_ERROR;
       }
     } else if (index_entry.offset != klv->offset + klv->consumed &&
         index_entry.offset != klv->offset + klv->data_offset) {
       GST_ERROR_OBJECT (demux,
-          "KLV offset doesn't match %" G_GINT64_FORMAT " entry offset %"
+          "KLV offset doesn't match %" G_GUINT64_FORMAT " entry offset %"
           G_GUINT64_FORMAT, klv->offset + klv->consumed, index_entry.offset);
       return GST_FLOW_ERROR;
     }
@@ -2913,7 +2946,7 @@
   }
 
   if (index_entry.initialized) {
-    GST_DEBUG_OBJECT (demux, "Got entry dts:%" G_GINT64_FORMAT " keyframe:%d",
+    GST_DEBUG_OBJECT (demux, "Got entry dts:%" G_GUINT64_FORMAT " keyframe:%d",
         index_entry.dts, index_entry.keyframe);
   }
   if (index_entry.initialized && !index_entry.keyframe)
@@ -2940,9 +2973,6 @@
     return ret;
   }
 
-  if (!etrack->offsets)
-    etrack->offsets = g_array_new (FALSE, TRUE, sizeof (GstMXFDemuxIndex));
-
   if (!index_entry.initialized) {
     /* This can happen when doing scanning without entry tables */
     index_entry.duration = 1;
@@ -2953,16 +2983,13 @@
         !GST_BUFFER_FLAG_IS_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
     index_entry.initialized = TRUE;
     GST_DEBUG_OBJECT (demux,
-        "Storing newly discovered information on track %d. dts: %"
-        G_GINT64_FORMAT " offset:%" G_GUINT64_FORMAT " keyframe:%d",
+        "Storing newly discovered information on track %u. dts: %"
+        G_GUINT64_FORMAT " offset:%" G_GUINT64_FORMAT " keyframe:%d",
         etrack->track_id, index_entry.dts, index_entry.offset,
         index_entry.keyframe);
 
-    /* We only ever append to the track offset entry. */
-    g_assert (etrack->position <= etrack->offsets->len);
-    g_array_insert_val (etrack->offsets, etrack->position, index_entry);
-  } else if (etrack->position == etrack->offsets->len) {
-    g_array_insert_val (etrack->offsets, etrack->position, index_entry);
+    have_new_essence_track_index_entry (demux, etrack, etrack->position,
+        &index_entry);
   }
 
   if (peek)
@@ -2991,8 +3018,8 @@
 
     if (etrack->position < pad->current_essence_track_position) {
       GST_DEBUG_OBJECT (pad,
-          "Not at current component's position (track:%" G_GINT64_FORMAT
-          " essence:%" G_GINT64_FORMAT ")", etrack->position,
+          "Not at current component's position (track:%" G_GUINT64_FORMAT
+          " essence:%" G_GUINT64_FORMAT ")", etrack->position,
           pad->current_essence_track_position);
       continue;
     }
@@ -3156,9 +3183,10 @@
     pad->current_essence_track_position += index_entry.duration;
 
     if (pad->current_component) {
-      if (pad->current_component_duration > 0 &&
-          pad->current_essence_track_position - pad->current_component_start
-          >= pad->current_component_duration) {
+      if ((pad->current_component_duration > 0
+              && pad->current_component_duration != -1)
+          && pad->current_essence_track_position -
+          pad->current_component_start >= pad->current_component_duration) {
         GST_DEBUG_OBJECT (demux, "Switching to next component");
 
         ret =
@@ -3170,13 +3198,13 @@
         } else if (ret != GST_FLOW_EOS) {
           GST_ERROR_OBJECT (demux, "Switching component failed");
         }
-      } else if (etrack->duration > 0
+      } else if ((etrack->duration > 0 && etrack->duration != -1)
           && pad->current_essence_track_position >= etrack->duration) {
         GST_DEBUG_OBJECT (demux,
             "Current component position after end of essence track");
         ret = GST_FLOW_EOS;
       }
-    } else if (etrack->duration > 0
+    } else if ((etrack->duration > 0 && etrack->duration != -1)
         && pad->current_essence_track_position == etrack->duration) {
       GST_DEBUG_OBJECT (demux, "At the end of the essence track");
       ret = GST_FLOW_EOS;
@@ -3565,7 +3593,7 @@
 gst_mxf_demux_pull_random_index_pack (GstMXFDemux * demux)
 {
   GstBuffer *buffer;
-  gint64 filesize = -1;
+  guint64 filesize = -1;
   GstFormat fmt = GST_FORMAT_BYTES;
   guint32 pack_size;
   guint64 old_offset = demux->offset;
@@ -3573,8 +3601,8 @@
   GstFlowReturn flow_ret;
   GstMXFKLV klv;
 
-  if (!gst_pad_peer_query_duration (demux->sinkpad, fmt, &filesize) ||
-      fmt != GST_FORMAT_BYTES || filesize == -1) {
+  if (!gst_pad_peer_query_duration (demux->sinkpad, fmt, (gint64 *) & filesize)
+      || fmt != GST_FORMAT_BYTES || filesize == -1) {
     GST_DEBUG_OBJECT (demux, "Can't query upstream size");
     return;
   }
@@ -3864,7 +3892,7 @@
   }
   if (demux->current_partition)
     GST_DEBUG_OBJECT (demux,
-        "Current partition now %p (body_sid:%d index_sid:%d this_partition:%"
+        "Current partition now %p (body_sid:%u index_sid:%u this_partition:%"
         G_GUINT64_FORMAT ")", demux->current_partition,
         demux->current_partition->partition.body_sid,
         demux->current_partition->partition.index_sid,
@@ -3874,10 +3902,10 @@
 }
 
 static guint64
-find_closest_offset (GArray * offsets, gint64 * position, gboolean keyframe)
+find_closest_offset (GArray * offsets, guint64 * position, gboolean keyframe)
 {
   GstMXFDemuxIndex *idx;
-  gint64 current_position = *position;
+  guint64 current_position = *position;
 
   if (!offsets || offsets->len == 0)
     return -1;
@@ -3885,14 +3913,13 @@
   current_position = MIN (current_position, offsets->len - 1);
 
   idx = &g_array_index (offsets, GstMXFDemuxIndex, current_position);
-  while (idx->offset == 0 || (keyframe && !idx->keyframe)) {
+  while ((!idx->initialized || (keyframe && !idx->keyframe))
+      && current_position > 0) {
     current_position--;
-    if (current_position < 0)
-      break;
     idx = &g_array_index (offsets, GstMXFDemuxIndex, current_position);
   }
 
-  if (idx->offset != 0 && (!keyframe || idx->keyframe)) {
+  if (idx->initialized && (!keyframe || idx->keyframe)) {
     *position = current_position;
     return idx->offset;
   }
@@ -3902,24 +3929,24 @@
 
 static guint64
 gst_mxf_demux_find_essence_element (GstMXFDemux * demux,
-    GstMXFDemuxEssenceTrack * etrack, gint64 * position, gboolean keyframe)
+    GstMXFDemuxEssenceTrack * etrack, guint64 * position, gboolean keyframe)
 {
   GstFlowReturn ret = GST_FLOW_OK;
   guint64 old_offset = demux->offset;
   GstMXFDemuxPartition *old_partition = demux->current_partition;
   gint i;
   guint64 offset;
-  gint64 requested_position = *position, index_start_position;
+  guint64 requested_position = *position, index_start_position;
   GstMXFDemuxIndex index_entry = { 0, };
 
-  GST_DEBUG_OBJECT (demux, "Trying to find essence element %" G_GINT64_FORMAT
+  GST_DEBUG_OBJECT (demux, "Trying to find essence element %" G_GUINT64_FORMAT
       " of track 0x%08x with body_sid %u (keyframe %d)", *position,
       etrack->track_number, etrack->body_sid, keyframe);
 
   /* Get entry from index table if present */
   if (find_edit_entry (demux, etrack, *position, keyframe, &index_entry)) {
     GST_DEBUG_OBJECT (demux,
-        "Got position %" G_GINT64_FORMAT " at offset %" G_GUINT64_FORMAT,
+        "Got position %" G_GUINT64_FORMAT " at offset %" G_GUINT64_FORMAT,
         index_entry.dts, index_entry.offset);
     *position = index_entry.dts;
     return index_entry.offset;
@@ -3934,14 +3961,15 @@
     offset = find_closest_offset (etrack->offsets, position, keyframe);
     if (offset != -1)
       GST_DEBUG_OBJECT (demux,
-          "Starting with edit unit %" G_GINT64_FORMAT " for %" G_GINT64_FORMAT
+          "Starting with edit unit %" G_GUINT64_FORMAT " for %" G_GUINT64_FORMAT
           " in generated index at offset %" G_GUINT64_FORMAT, *position,
           requested_position, offset);
     return offset;
   }
 
-  if (etrack->duration > 0 && *position >= etrack->duration) {
-    GST_WARNING_OBJECT (demux, "Position after end of essence track");
+  if ((etrack->duration > 0 && etrack->duration != -1)
+      && *position >= etrack->duration) {
+    GST_DEBUG_OBJECT (demux, "Position after end of essence track");
     return -1;
   }
 
@@ -3955,7 +3983,7 @@
   if (offset != -1) {
     demux->offset = offset + demux->run_in;
     GST_DEBUG_OBJECT (demux,
-        "Starting with edit unit %" G_GINT64_FORMAT " for %" G_GINT64_FORMAT
+        "Starting with edit unit %" G_GUINT64_FORMAT " for %" G_GUINT64_FORMAT
         " in generated index at offset %" G_GUINT64_FORMAT,
         index_start_position, requested_position, offset);
   } else {
@@ -3971,7 +3999,7 @@
       t->position = index_start_position;
     else
       t->position = (demux->offset == demux->run_in) ? 0 : -1;
-    GST_LOG_OBJECT (demux, "Setting track %d position to %" G_GINT64_FORMAT,
+    GST_LOG_OBJECT (demux, "Setting track %u position to %" G_GUINT64_FORMAT,
         t->track_id, t->position);
   }
 
@@ -3981,7 +4009,7 @@
   while (ret == GST_FLOW_OK) {
     GstMXFKLV klv;
 
-    GST_LOG_OBJECT (demux, "Pulling from offset %" G_GINT64_FORMAT,
+    GST_LOG_OBJECT (demux, "Pulling from offset %" G_GUINT64_FORMAT,
         demux->offset);
     ret = gst_mxf_demux_peek_klv_packet (demux, demux->offset, &klv);
 
@@ -3991,7 +4019,7 @@
         GstMXFDemuxEssenceTrack *t =
             g_ptr_array_index (demux->essence_tracks, i);
 
-        if (t->position > 0)
+        if (t->position > 0 && t->position != -1)
           t->duration = t->position;
       }
       /* For the searched track this is really our position */
@@ -4009,7 +4037,7 @@
     }
 
     GST_LOG_OBJECT (demux,
-        "pulling gave flow:%s track->position:%" G_GINT64_FORMAT,
+        "pulling gave flow:%s track->position:%" G_GUINT64_FORMAT,
         gst_flow_get_name (ret), etrack->position);
     if (G_UNLIKELY (ret != GST_FLOW_OK) && etrack->position <= *position) {
       demux->offset = old_offset;
@@ -4021,23 +4049,23 @@
     }
 
     GST_LOG_OBJECT (demux,
-        "Handling gave flow:%s track->position:%" G_GINT64_FORMAT
-        " looking for %" G_GINT64_FORMAT, gst_flow_get_name (ret),
+        "Handling gave flow:%s track->position:%" G_GUINT64_FORMAT
+        " looking for %" G_GUINT64_FORMAT, gst_flow_get_name (ret),
         etrack->position, *position);
 
     /* If we found the position read it from the index again */
     if (((ret == GST_FLOW_OK && etrack->position == *position + 1) ||
             (ret == GST_FLOW_EOS && etrack->position == *position + 1))
-        && etrack->offsets && etrack->offsets->len > *position
+        && etrack->offsets->len > *position
         && g_array_index (etrack->offsets, GstMXFDemuxIndex,
-            *position).offset != 0) {
+            *position).initialized) {
       GST_DEBUG_OBJECT (demux, "Found at offset %" G_GUINT64_FORMAT,
           demux->offset);
       demux->offset = old_offset;
       demux->current_partition = old_partition;
       if (find_edit_entry (demux, etrack, *position, keyframe, &index_entry)) {
         GST_DEBUG_OBJECT (demux,
-            "Got position %" G_GINT64_FORMAT " at offset %" G_GUINT64_FORMAT,
+            "Got position %" G_GUINT64_FORMAT " at offset %" G_GUINT64_FORMAT,
             index_entry.dts, index_entry.offset);
         *position = index_entry.dts;
         return index_entry.offset;
@@ -4104,9 +4132,9 @@
         GstMXFDemuxPad *p = g_ptr_array_index (demux->src, i);
 
         GST_DEBUG_OBJECT (p,
-            "eos:%d current_essence_track_position:%" G_GINT64_FORMAT
-            " position:%" G_GINT64_FORMAT " duration:%" G_GINT64_FORMAT, p->eos,
-            p->current_essence_track_position,
+            "eos:%d current_essence_track_position:%" G_GUINT64_FORMAT
+            " position:%" G_GUINT64_FORMAT " duration:%" G_GUINT64_FORMAT,
+            p->eos, p->current_essence_track_position,
             p->current_essence_track->position,
             p->current_essence_track->duration);
         if (!p->eos
@@ -4118,7 +4146,7 @@
 
       while ((p = gst_mxf_demux_get_earliest_pad (demux))) {
         guint64 offset;
-        gint64 position;
+        guint64 position;
 
         GST_DEBUG_OBJECT (p, "Trying on earliest");
 
@@ -4175,7 +4203,7 @@
       if (partition->partition.body_sid != 0) {
         guint64 lowest_offset = G_MAXUINT64;
         GST_DEBUG_OBJECT (demux,
-            "Entered partition (body_sid:%d index_sid:%d body_offset:%"
+            "Entered partition (body_sid:%u index_sid:%u body_offset:%"
             G_GUINT64_FORMAT "), checking positions",
             partition->partition.body_sid, partition->partition.index_sid,
             partition->partition.body_offset);
@@ -4197,7 +4225,7 @@
           } else if (partition->single_track->position != 0) {
             GstMXFDemuxIndex entry;
             GST_DEBUG_OBJECT (demux,
-                "Track already at another position : %" G_GINT64_FORMAT,
+                "Track already at another position : %" G_GUINT64_FORMAT,
                 partition->single_track->position);
             if (find_edit_entry (demux, partition->single_track,
                     partition->single_track->position, FALSE, &entry)) {
@@ -4217,7 +4245,7 @@
             if (etrack->body_sid != partition->partition.body_sid)
               continue;
             if (etrack->position == -1 && partition->partition.body_offset == 0) {
-              GST_DEBUG_OBJECT (demux, "Resetting track %d to position 0",
+              GST_DEBUG_OBJECT (demux, "Resetting track %u to position 0",
                   etrack->track_id);
 
               etrack->position = 0;
@@ -4272,7 +4300,7 @@
             gst_mxf_demux_pad_get_current_time (demux,
                 earliest) > demux->max_drift)) {
       guint64 offset;
-      gint64 position;
+      guint64 position;
 
       GST_DEBUG_OBJECT (demux,
           "Found synchronization issue -- trying to solve");
@@ -4300,7 +4328,7 @@
       gst_mxf_demux_set_partition_for_offset (demux, demux->offset);
       GST_DEBUG_OBJECT (demux,
           "Switching to offset %" G_GUINT64_FORMAT " for position %"
-          G_GINT64_FORMAT " on track %d (body_sid:%d index_sid:%d)",
+          G_GUINT64_FORMAT " on track %u (body_sid:%u index_sid:%u)",
           demux->offset, position, earliest->current_essence_track->track_id,
           earliest->current_essence_track->body_sid,
           earliest->current_essence_track->index_sid);
@@ -4633,9 +4661,9 @@
 static gboolean
 gst_mxf_demux_pad_to_track_and_position (GstMXFDemux * demux,
     GstMXFDemuxPad * pad, GstClockTime streamtime,
-    GstMXFDemuxEssenceTrack ** etrack, gint64 * position)
+    GstMXFDemuxEssenceTrack ** etrack, guint64 * position)
 {
-  gint64 material_position;
+  guint64 material_position;
   guint64 sum = 0;
   guint i;
   MXFMetadataSourceClip *clip = NULL;
@@ -4647,7 +4675,7 @@
       pad->material_track->edit_rate.d * GST_SECOND);
 
   GST_DEBUG_OBJECT (pad,
-      "streamtime %" GST_TIME_FORMAT " position %" G_GINT64_FORMAT,
+      "streamtime %" GST_TIME_FORMAT " position %" G_GUINT64_FORMAT,
       GST_TIME_ARGS (streamtime), material_position);
 
 
@@ -4658,8 +4686,8 @@
         MXF_METADATA_SOURCE_CLIP (pad->material_track->parent.sequence->
         structural_componentsi);
     GST_LOG_OBJECT (pad,
-        "clip %d start_position:%" G_GINT64_FORMAT " duration %"
-        G_GINT64_FORMAT, clip->source_track_id, clip->start_position,
+        "clip %u start_position:%" G_GUINT64_FORMAT " duration %"
+        G_GUINT64_FORMAT, clip->source_track_id, clip->start_position,
         clip->parent.duration);
     if (clip->parent.duration <= 0)
       break;
@@ -4675,7 +4703,7 @@
     sum -= clip->parent.duration;
   }
 
-  GST_DEBUG_OBJECT (pad, "Looking for essence track for track_id:%d umid:%s",
+  GST_DEBUG_OBJECT (pad, "Looking for essence track for track_id:%u umid:%s",
       clip->source_track_id, mxf_umid_to_string (&clip->source_package_id,
           str));
 
@@ -4683,13 +4711,13 @@
   for (i = 0; i < demux->essence_tracks->len; i++) {
     GstMXFDemuxEssenceTrack *track =
         g_ptr_array_index (demux->essence_tracks, i);
-    GST_LOG_OBJECT (pad, "Looking at essence track body_sid:%d index_sid:%d",
+    GST_LOG_OBJECT (pad, "Looking at essence track body_sid:%u index_sid:%u",
         track->body_sid, track->index_sid);
     if (clip->source_track_id == 0 || (track->track_id == clip->source_track_id
             && mxf_umid_is_equal (&clip->source_package_id,
                 &track->source_package_uid))) {
       GST_DEBUG_OBJECT (pad,
-          "Found matching essence track body_sid:%d index_sid:%d",
+          "Found matching essence track body_sid:%u index_sid:%u",
           track->body_sid, track->index_sid);
       *etrack = track;
       *position = material_position - sum;
@@ -4704,7 +4732,7 @@
 static gboolean
 gst_mxf_demux_pad_get_stream_time (GstMXFDemux * demux,
     GstMXFDemuxPad * pad, GstMXFDemuxEssenceTrack * etrack,
-    gint64 position, GstClockTime * stream_time)
+    guint64 position, GstClockTime * stream_time)
 {
   guint i;
   guint64 sum = 0;
@@ -4718,8 +4746,8 @@
         MXF_METADATA_SOURCE_CLIP (pad->material_track->parent.sequence->
         structural_componentsi);
     GST_LOG_OBJECT (pad,
-        "clip %d start_position:%" G_GINT64_FORMAT " duration %"
-        G_GINT64_FORMAT, clip->source_track_id, clip->start_position,
+        "clip %u start_position:%" G_GUINT64_FORMAT " duration %"
+        G_GUINT64_FORMAT, clip->source_track_id, clip->start_position,
         clip->parent.duration);
     if (etrack->track_id == clip->source_track_id
         && mxf_umid_is_equal (&clip->source_package_id,
@@ -4793,7 +4821,7 @@
     return;
   }
 
-  if (clip->parent.duration > 0)
+  if (clip->parent.duration > 0 && clip->parent.duration != -1)
     sum -= clip->parent.duration;
 
   start -=
@@ -4803,7 +4831,7 @@
   gst_mxf_demux_pad_set_component (demux, p, i);
 
   {
-    gint64 essence_offset = gst_util_uint64_scale (start,
+    guint64 essence_offset = gst_util_uint64_scale (start,
         p->current_essence_track->source_track->edit_rate.n,
         p->current_essence_track->source_track->edit_rate.d * GST_SECOND);
 
@@ -4811,8 +4839,10 @@
     p->current_material_track_position = sum + essence_offset;
   }
 
-  if (p->current_essence_track->duration > 0 &&
-      p->current_essence_track_position >= p->current_essence_track->duration) {
+  if ((p->current_essence_track->duration > 0
+          && p->current_essence_track->duration != -1)
+      && p->current_essence_track_position >=
+      p->current_essence_track->duration) {
     p->current_essence_track_position = p->current_essence_track->duration;
     p->current_material_track_position =
         sum + p->current_component->parent.duration;
@@ -4845,7 +4875,7 @@
   GstFormat format;
   GstSeekFlags flags;
   GstSeekType start_type, stop_type;
-  gint64 start, stop;
+  guint64 start, stop;
   gdouble rate;
   gboolean update, flush, keyframe;
   GstSegment seeksegment;
@@ -4853,7 +4883,7 @@
   guint32 seqnum;
 
   gst_event_parse_seek (event, &rate, &format, &flags,
-      &start_type, &start, &stop_type, &stop);
+      &start_type, (gint64 *) & start, &stop_type, (gint64 *) & stop);
   seqnum = gst_event_get_seqnum (event);
 
   if (rate <= 0.0)
@@ -4893,7 +4923,7 @@
     /* Do the actual seeking */
     for (i = 0; i < demux->src->len; i++) {
       GstMXFDemuxPad *p = g_ptr_array_index (demux->src, i);
-      gint64 position;
+      guint64 position;
       guint64 off;
 
       /* Reset EOS flag on all pads */
@@ -5014,7 +5044,7 @@
 #endif
 
     GST_LOG_OBJECT (demux,
-        "Collecting from segment bodySID:%d indexSID:%d instance_id: %s",
+        "Collecting from segment bodySID:%u indexSID:%u instance_id: %s",
         segment->body_sid, segment->index_sid,
         mxf_uuid_to_string (&segment->instance_id, str));
 
@@ -5050,7 +5080,7 @@
       if (delta->pos_table_index == -1) {
         if (t->reordered_delta_entry != -1 && didx != t->reordered_delta_entry)
           GST_WARNING_OBJECT (demux,
-              "Index Table specifies more than one stream using temporal reordering (%d and %d)",
+              "Index Table specifies more than one stream using temporal reordering (%u and %d)",
               didx, t->reordered_delta_entry);
         else
           t->reordered_delta_entry = didx;
@@ -5071,14 +5101,14 @@
       continue;
 
     GST_DEBUG_OBJECT (demux,
-        "bodySID:%d indexSID:%d Calculating reverse temporal offset table",
+        "bodySID:%u indexSID:%u Calculating reverse temporal offset table",
         table->body_sid, table->index_sid);
 
     for (segidx = 0; segidx < table->segments->len; segidx++) {
       MXFIndexTableSegment *s =
           &g_array_index (table->segments, MXFIndexTableSegment, segidx);
-      guint start = s->index_start_position;
-      guint stop =
+      guint64 start = s->index_start_position;
+      guint64 stop =
           s->index_duration ? start + s->index_duration : start +
           s->n_index_entries;
       guint entidx = 0;
@@ -5093,8 +5123,8 @@
         if (start + entidx + entry->temporal_offset >=
             table->reverse_temporal_offsets->len) {
           GST_ERROR_OBJECT (demux,
-              "Temporal offset exceeds boundaries. entry:%d offset:%d max:%d",
-              start + entidx, entry->temporal_offset,
+              "Temporal offset exceeds boundaries. entry:%" G_GUINT64_FORMAT
+              " offset:%d max:%u", start + entidx, entry->temporal_offset,
               table->reverse_temporal_offsets->len);
         } else {
           /* Applying the temporal offset gives us the entry that should contain this PTS.
@@ -5126,7 +5156,7 @@
   GstFormat format;
   GstSeekFlags flags;
   GstSeekType start_type, stop_type;
-  gint64 start, stop;
+  guint64 start, stop;
   gdouble rate;
   gboolean update, flush, keyframe;
   GstSegment seeksegment;
@@ -5135,7 +5165,7 @@
   guint32 seqnum;
 
   gst_event_parse_seek (event, &rate, &format, &flags,
-      &start_type, &start, &stop_type, &stop);
+      &start_type, (gint64 *) & start, &stop_type, (gint64 *) & stop);
   seqnum = gst_event_get_seqnum (event);
 
   if (seqnum == demux->seqnum) {
@@ -5224,7 +5254,7 @@
   for (i = 0; i < demux->src->len; i++) {
     GstMXFDemuxPad *p = g_ptr_array_index (demux->src, i);
     GstMXFDemuxEssenceTrack *etrack;
-    gint64 track_pos, seeked_pos;
+    guint64 track_pos, seeked_pos;
 
     /* Get track and track position for requested time, handles out of bound internally */
     if (!gst_mxf_demux_pad_to_track_and_position (demux, p,
@@ -5232,7 +5262,7 @@
       goto invalid_position;
 
     GST_LOG_OBJECT (p,
-        "track %d (body_sid:%d index_sid:%d), position %" G_GINT64_FORMAT,
+        "track %u (body_sid:%u index_sid:%u), position %" G_GUINT64_FORMAT,
         etrack->track_id, etrack->body_sid, etrack->index_sid, track_pos);
 
     /* Find supporting keyframe entry */
@@ -5244,9 +5274,9 @@
     }
 
     GST_LOG_OBJECT (p,
-        "track %d (body_sid:%d index_sid:%d), position %" G_GINT64_FORMAT
-        " entry position %" G_GINT64_FORMAT, etrack->track_id, etrack->body_sid,
-        etrack->index_sid, track_pos, seeked_pos);
+        "track %u (body_sid:%u index_sid:%u), position %" G_GUINT64_FORMAT
+        " entry position %" G_GUINT64_FORMAT, etrack->track_id,
+        etrack->body_sid, etrack->index_sid, track_pos, seeked_pos);
 
     if (seeked_pos != track_pos) {
       GstClockTime stream_time;
@@ -5273,7 +5303,7 @@
     /* Do the actual seeking */
     for (i = 0; i < demux->src->len; i++) {
       GstMXFDemuxPad *p = g_ptr_array_index (demux->src, i);
-      gint64 position;
+      guint64 position;
       guint64 off;
 
       /* Reset EOS flag on all pads */
@@ -5440,7 +5470,7 @@
     case GST_QUERY_POSITION:
     {
       GstFormat format;
-      gint64 pos;
+      guint64 pos;
 
       gst_query_parse_position (query, &format, NULL);
       if (format != GST_FORMAT_TIME && format != GST_FORMAT_DEFAULT)
@@ -5452,7 +5482,7 @@
           gst_mxf_demux_pad_get_current_time (demux, mxfpad);
 
       GST_DEBUG_OBJECT (pad,
-          "Returning position %" G_GINT64_FORMAT " in format %s", pos,
+          "Returning position %" G_GUINT64_FORMAT " in format %s", pos,
           gst_format_get_name (format));
 
       gst_query_set_position (query, format, pos);
@@ -5461,7 +5491,7 @@
       break;
     }
     case GST_QUERY_DURATION:{
-      gint64 duration;
+      guint64 duration;
       GstFormat format;
 
       gst_query_parse_duration (query, &format, NULL);
@@ -5475,8 +5505,6 @@
       }
 
       duration = mxfpad->material_track->parent.sequence->duration;
-      if (duration <= -1)
-        duration = -1;
 
       if (duration != -1 && format == GST_FORMAT_TIME) {
         if (mxfpad->material_track->edit_rate.n == 0 ||
@@ -5493,7 +5521,7 @@
       g_rw_lock_reader_unlock (&demux->metadata_lock);
 
       GST_DEBUG_OBJECT (pad,
-          "Returning duration %" G_GINT64_FORMAT " in format %s", duration,
+          "Returning duration %" G_GUINT64_FORMAT " in format %s", duration,
           gst_format_get_name (format));
 
       gst_query_set_duration (query, format, duration);
@@ -5502,7 +5530,7 @@
     }
     case GST_QUERY_SEEKING:{
       GstFormat fmt;
-      gint64 duration;
+      guint64 duration;
 
       ret = TRUE;
       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
@@ -5511,7 +5539,7 @@
         goto done;
       }
 
-      if (!gst_pad_query_duration (pad, GST_FORMAT_TIME, &duration)) {
+      if (!gst_pad_query_duration (pad, GST_FORMAT_TIME, (gint64 *) & duration)) {
         gst_query_set_seeking (query, fmt, FALSE, -1, -1);
         goto done;
       }
@@ -5537,7 +5565,7 @@
     }
     case GST_QUERY_SEGMENT:{
       GstFormat format;
-      gint64 start, stop;
+      guint64 start, stop;
 
       format = demux->segment.format;
 
@@ -5652,7 +5680,7 @@
         GstMXFDemuxEssenceTrack *t =
             g_ptr_array_index (demux->essence_tracks, i);
 
-        if (t->position > 0)
+        if (t->position > 0 && t->position != -1)
           t->duration = t->position;
       }
 
@@ -5667,7 +5695,7 @@
 
       while ((p = gst_mxf_demux_get_earliest_pad (demux))) {
         guint64 offset;
-        gint64 position;
+        guint64 position;
 
         position = p->current_essence_track_position;
 
@@ -5743,7 +5771,7 @@
     case GST_QUERY_POSITION:
     {
       GstFormat format;
-      gint64 pos;
+      guint64 pos;
 
       gst_query_parse_position (query, &format, NULL);
       if (format != GST_FORMAT_TIME)
@@ -5752,7 +5780,7 @@
       pos = demux->segment.position;
 
       GST_DEBUG_OBJECT (demux,
-          "Returning position %" G_GINT64_FORMAT " in format %s", pos,
+          "Returning position %" G_GUINT64_FORMAT " in format %s", pos,
           gst_format_get_name (format));
 
       gst_query_set_position (query, format, pos);
@@ -5761,7 +5789,7 @@
       break;
     }
     case GST_QUERY_DURATION:{
-      gint64 duration = -1;
+      guint64 duration = -1;
       GstFormat format;
       guint i;
 
@@ -5775,14 +5803,14 @@
       g_rw_lock_reader_lock (&demux->metadata_lock);
       for (i = 0; i < demux->src->len; i++) {
         GstMXFDemuxPad *pad = g_ptr_array_index (demux->src, i);
-        gint64 pdur = -1;
+        guint64 pdur = -1;
 
         if (!pad->material_track || !pad->material_track->parent.sequence)
           continue;
 
         pdur = pad->material_track->parent.sequence->duration;
         if (pad->material_track->edit_rate.n == 0 ||
-            pad->material_track->edit_rate.d == 0 || pdur <= -1)
+            pad->material_track->edit_rate.d == 0 || pdur == -1)
           continue;
 
         pdur =
@@ -5799,7 +5827,7 @@
       }
 
       GST_DEBUG_OBJECT (demux,
-          "Returning duration %" G_GINT64_FORMAT " in format %s", duration,
+          "Returning duration %" G_GUINT64_FORMAT " in format %s", duration,
           gst_format_get_name (format));
 
       gst_query_set_duration (query, format, duration);
@@ -5835,7 +5863,7 @@
     }
     case GST_QUERY_SEGMENT:{
       GstFormat format;
-      gint64 start, stop;
+      guint64 start, stop;
 
       format = demux->segment.format;

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mxf/mxfdemux.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mxf/mxfdemux.h Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mxf/mxfmetadata.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mxf/mxfmetadata.c Changed

@@ -2623,7 +2623,7 @@
       if (tag_size != 8)
         goto error;
       self->origin = GST_READ_UINT64_BE (tag_data);
-      GST_DEBUG ("  origin = %" G_GINT64_FORMAT, self->origin);
+      GST_DEBUG ("  origin = %" G_GUINT64_FORMAT, self->origin);
       break;
     default:
       ret =
@@ -2729,7 +2729,7 @@
       if (tag_size != 8)
         goto error;
       self->event_origin = GST_READ_UINT64_BE (tag_data);
-      GST_DEBUG ("  event origin = %" G_GINT64_FORMAT, self->event_origin);
+      GST_DEBUG ("  event origin = %" G_GUINT64_FORMAT, self->event_origin);
       break;
     default:
       ret =
@@ -2868,7 +2868,7 @@
       if (tag_size != 8)
         goto error;
       self->duration = GST_READ_UINT64_BE (tag_data);
-      GST_DEBUG ("  duration = %" G_GINT64_FORMAT, self->duration);
+      GST_DEBUG ("  duration = %" G_GUINT64_FORMAT, self->duration);
       break;
     case 0x1001:
       if (!mxf_uuid_array_parse (&self->structural_components_uids,
@@ -3092,7 +3092,7 @@
       if (tag_size != 8)
         goto error;
       self->duration = GST_READ_UINT64_BE (tag_data);
-      GST_DEBUG ("  duration = %" G_GINT64_FORMAT, self->duration);
+      GST_DEBUG ("  duration = %" G_GUINT64_FORMAT, self->duration);
       break;
     default:
       ret =
@@ -3200,7 +3200,7 @@
       if (tag_size != 8)
         goto error;
       self->start_timecode = GST_READ_UINT64_BE (tag_data);
-      GST_DEBUG ("  start timecode = %" G_GINT64_FORMAT, self->start_timecode);
+      GST_DEBUG ("  start timecode = %" G_GUINT64_FORMAT, self->start_timecode);
       break;
     case 0x1503:
       if (tag_size != 1)
@@ -3320,7 +3320,7 @@
         goto error;
 
       self->start_position = GST_READ_UINT64_BE (tag_data);
-      GST_DEBUG ("  start position = %" G_GINT64_FORMAT, self->start_position);
+      GST_DEBUG ("  start position = %" G_GUINT64_FORMAT, self->start_position);
       break;
     case 0x1101:
       if (tag_size != 32)
@@ -3682,7 +3682,7 @@
       if (tag_size != 8)
         goto error;
       self->event_start_position = GST_READ_UINT64_BE (tag_data);
-      GST_DEBUG ("  event start position = %" G_GINT64_FORMAT,
+      GST_DEBUG ("  event start position = %" G_GUINT64_FORMAT,
           self->event_start_position);
       break;
     case 0x0602:
@@ -4189,7 +4189,7 @@
       if (tag_size != 8)
         goto error;
       self->container_duration = GST_READ_UINT64_BE (tag_data);
-      GST_DEBUG ("  container duration = %" G_GINT64_FORMAT,
+      GST_DEBUG ("  container duration = %" G_GUINT64_FORMAT,
           self->container_duration);
       break;
     case 0x3004:

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mxf/mxfmetadata.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mxf/mxfmetadata.h Changed

@@ -548,14 +548,14 @@
   MXFMetadataTrack parent;
 
   MXFFraction edit_rate;
-  gint64 origin;
+  guint64 origin;
 };
 
 struct _MXFMetadataEventTrack {
   MXFMetadataTrack parent;
 
   MXFFraction event_edit_rate;
-  gint64 event_origin;
+  guint64 event_origin;
 };
 
 struct _MXFMetadataSequence {
@@ -563,7 +563,7 @@
 
   MXFUL data_definition;
 
-  gint64 duration;
+  guint64 duration;
 
   guint32 n_structural_components;
   MXFUUID *structural_components_uids;
@@ -574,13 +574,13 @@
   MXFMetadata parent;
 
   MXFUL data_definition;
-  gint64 duration;
+  guint64 duration;
 };
 
 struct _MXFMetadataTimecodeComponent {
   MXFMetadataStructuralComponent parent;
 
-  gint64 start_timecode;
+  guint64 start_timecode;
   guint16 rounded_timecode_base;
   gboolean drop_frame;
 };
@@ -588,7 +588,7 @@
 struct _MXFMetadataSourceClip {
   MXFMetadataStructuralComponent parent;
 
-  gint64 start_position;
+  guint64 start_position;
   MXFUMID source_package_id;
   MXFMetadataSourcePackage *source_package;
 
@@ -609,7 +609,7 @@
 struct _MXFMetadataDMSegment {
   MXFMetadataStructuralComponent parent;
 
-  gint64 event_start_position;
+  guint64 event_start_position;
   gchar *event_comment;
 
   guint32 n_track_ids;
@@ -637,7 +637,7 @@
   guint32 linked_track_id;
 
   MXFFraction sample_rate;
-  gint64 container_duration;
+  guint64 container_duration;
 
   MXFUL essence_container;
   MXFUL codec;

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mxf/mxftypes.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mxf/mxftypes.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/mxf/mxftypes.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/mxf/mxftypes.h Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/pcapparse/gstpcapparse.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/pcapparse/gstpcapparse.c Changed

@@ -354,6 +354,7 @@
 #define SLL2_HEADER_LEN    20
 #define IP_HEADER_MIN_LEN 20
 #define UDP_HEADER_LEN     8
+#define TCP_HEADER_MIN_LEN 20
 
 #define IP_PROTO_UDP      17
 #define IP_PROTO_TCP      6
@@ -438,7 +439,8 @@
     return FALSE;
 
   ip_header_size = (b & 0x0f) * 4;
-  if (buf_ip + ip_header_size > buf + buf_size)
+  if (ip_header_size < IP_HEADER_MIN_LEN ||
+      buf_ip + ip_header_size > buf + buf_size)
     return FALSE;
 
   flags = buf_ip6 >> 5;
@@ -460,6 +462,11 @@
   memcpy (&ip_dst_addr, buf_ip + 16, sizeof (ip_dst_addr));
   buf_proto = buf_ip + ip_header_size;
   ip_packet_len = GUINT16_FROM_BE (*(guint16 *) (buf_ip + 2));
+  if (ip_packet_len < ip_header_size)
+    return FALSE;
+
+  if (buf_proto + 4 > buf + buf_size)
+    return FALSE;
 
   /* ok for tcp and udp */
   src_port = GUINT16_FROM_BE (*((guint16 *) (buf_proto + 0)));
@@ -467,6 +474,8 @@
 
   /* extract some params and data according to protocol */
   if (ip_protocol == IP_PROTO_UDP) {
+    if (buf_proto + 6 > buf + buf_size)
+      return FALSE;
     len = GUINT16_FROM_BE (*((guint16 *) (buf_proto + 4)));
     if (len < UDP_HEADER_LEN || buf_proto + len > buf + buf_size)
       return FALSE;
@@ -474,10 +483,13 @@
     *payload = buf_proto + UDP_HEADER_LEN;
     *payload_size = len - UDP_HEADER_LEN;
   } else {
-    if (buf_proto + 12 >= buf + buf_size)
+    if (buf_proto + 13 > buf + buf_size)
       return FALSE;
     len = (buf_proto12 >> 4) * 4;
-    if (buf_proto + len > buf + buf_size)
+    if (len < TCP_HEADER_MIN_LEN || buf_proto + len > buf + buf_size)
+      return FALSE;
+    if (ip_packet_len < ip_header_size + len ||
+        buf_ip + ip_packet_len > buf + buf_size)
       return FALSE;
 
     /* all remaining data following tcp header is payload */

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/pnm/gstpnmdec.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/pnm/gstpnmdec.c Changed

@@ -140,7 +140,10 @@
       if (pnmdec->mngr.info.encoding == GST_PNM_ENCODING_ASCII) {
         return GST_FLOW_ERROR;
       }
-      pnmdec->size = pnmdec->mngr.info.width * pnmdec->mngr.info.height * 1;
+      if (!g_uint_checked_mul (&pnmdec->size, pnmdec->mngr.info.width,
+              pnmdec->mngr.info.height)) {
+        return GST_FLOW_NOT_NEGOTIATED;
+      }
       fmt = GST_VIDEO_FORMAT_GRAY8;
       break;
     case GST_PNM_TYPE_GRAYMAP:
@@ -150,7 +153,11 @@
         GstStructure *peerstruct;
         const gchar *fmtstr;
 
-        pnmdec->size = pnmdec->mngr.info.width * pnmdec->mngr.info.height * 2;
+        if (!g_uint_checked_mul (&pnmdec->size, pnmdec->mngr.info.width,
+                pnmdec->mngr.info.height)
+            || !g_uint_checked_mul (&pnmdec->size, pnmdec->size, 2)) {
+          return GST_FLOW_NOT_NEGOTIATED;
+        }
         /* perform some basic negotiation to resolve which endianness,
          * if any, is supported by the component downstream. Query
          * the peer caps, intersecting with our preferred caps
@@ -180,14 +187,24 @@
         }
         gst_caps_unref (peercaps);
       } else {
-        pnmdec->size = pnmdec->mngr.info.width * pnmdec->mngr.info.height * 1;
+        if (!g_uint_checked_mul (&pnmdec->size, pnmdec->mngr.info.width,
+                pnmdec->mngr.info.height)) {
+          return GST_FLOW_NOT_NEGOTIATED;
+        }
         fmt = GST_VIDEO_FORMAT_GRAY8;
       }
       break;
     case GST_PNM_TYPE_PIXMAP:
-      pnmdec->size = pnmdec->mngr.info.width * pnmdec->mngr.info.height * 3;
+      if (!g_uint_checked_mul (&pnmdec->size, pnmdec->mngr.info.width,
+              pnmdec->mngr.info.height)
+          || !g_uint_checked_mul (&pnmdec->size, pnmdec->size, 3)) {
+        return GST_FLOW_NOT_NEGOTIATED;
+      }
       fmt = GST_VIDEO_FORMAT_RGB;
       break;
+    case GST_PNM_TYPE_UNKNOWN:
+      fmt = GST_VIDEO_FORMAT_UNKNOWN;
+      break;
   }
 
   if (fmt == GST_VIDEO_FORMAT_UNKNOWN)
@@ -200,7 +217,7 @@
       pnmdec->mngr.info.width, pnmdec->mngr.info.height, pnmdec->input_state);
   gst_video_codec_state_unref (output_state);
 
-  if (gst_video_decoder_negotiate (decoder) == FALSE)
+  if (!gst_video_decoder_negotiate (decoder))
     return GST_FLOW_NOT_NEGOTIATED;
 
   return GST_FLOW_OK;
@@ -211,7 +228,10 @@
 {
   GstPnmdec *pnmdec = (GstPnmdec *) decoder;
 
-  gst_pnmdec_negotiate (decoder);
+  if (pnmdec->mngr.info.type != GST_PNM_TYPE_UNKNOWN) {
+    if (gst_pnmdec_negotiate (decoder) != GST_FLOW_OK)
+      return FALSE;
+  }
 
   if (pnmdec->input_state)
     gst_video_codec_state_unref (pnmdec->input_state);
@@ -230,10 +250,8 @@
     pnmdec->input_state = NULL;
   }
 
-  if (pnmdec->buf) {
-    gst_buffer_unref (pnmdec->buf);
-    pnmdec->buf = NULL;
-  }
+  gst_pnmdec_flush (pnmdec);
+
   return TRUE;
 }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/pnm/gstpnmutils.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/pnm/gstpnmutils.h Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/rtmp2/rtmp/rtmpclient.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/rtmp2/rtmp/rtmpclient.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/rtmp2/rtmp/rtmpconnection.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/rtmp2/rtmp/rtmpconnection.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/rtp/gstrtpsink.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/rtp/gstrtpsink.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/videoparsers/gsth264parse.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/videoparsers/gsth264parse.c Changed

@@ -214,7 +214,7 @@
 
   gst_video_clear_user_data_unregistered (&h264parse->user_data_unregistered,
       TRUE);
-  gst_video_clear_user_data (&h264parse->user_data, TRUE);
+  gst_video_clear_user_data (&h264parse->user_data);
 
   g_object_unref (h264parse->frame_out);
 
@@ -243,7 +243,7 @@
   h264parse->have_pps_in_frame = FALSE;
   h264parse->have_aud_in_frame = FALSE;
   gst_adapter_clear (h264parse->frame_out);
-  gst_video_clear_user_data (&h264parse->user_data, FALSE);
+  gst_video_clear_user_data (&h264parse->user_data);
   gst_video_clear_user_data_unregistered (&h264parse->user_data_unregistered,
       FALSE);
 }
@@ -1106,7 +1106,8 @@
       h264parse->picture_start = TRUE;
 
       /* don't need to parse the whole slice (header) here */
-      if (*(nalu->data + nalu->offset + nalu->header_bytes) & 0x80) {
+      if (nalu->size > nalu->header_bytes &&
+          *(nalu->data + nalu->offset + nalu->header_bytes) & 0x80) {
         /* means first_mb_in_slice == 0 */
         /* real frame data */
         GST_DEBUG_OBJECT (h264parse, "first_mb_in_slice = 0");
@@ -1927,9 +1928,10 @@
       g_value_unset (&value);
     }
     gst_caps_set_value (caps, "profile", &compat_profiles);
-    g_value_unset (&compat_profiles);
   }
 
+  g_value_unset (&compat_profiles);
+
   return caps;
 }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/videoparsers/gsth265parse.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/videoparsers/gsth265parse.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/videoparsers/gstmpeg4videoparse.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/videoparsers/gstmpeg4videoparse.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/videoparsers/gstmpegvideoparse.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/videoparsers/gstmpegvideoparse.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/videoparsers/gstvideoparseutils.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/videoparsers/gstvideoparseutils.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/videoparsers/gstvideoparseutils.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/videoparsers/gstvideoparseutils.h Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/gst/vmnc/vmncdec.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/gst/vmnc/vmncdec.c Changed

@@ -155,6 +155,20 @@
 typedef int (*rectangle_handler) (GstVMncDec * dec, struct RfbRectangle * rect,
     const guint8 * data, int len, gboolean decode);
 
+static gboolean
+vmnc_rect_payload_size (struct RfbRectangle *rect, guint bytes_per_pixel,
+    gsize * size)
+{
+  gsize pixels;
+
+  if (!g_size_checked_mul (&pixels, rect->width, rect->height))
+    return FALSE;
+  if (!g_size_checked_mul (size, pixels, bytes_per_pixel))
+    return FALSE;
+
+  return TRUE;
+}
+
 static int
 vmnc_handle_wmvi_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
     const guint8 * data, int len, gboolean decode)
@@ -395,7 +409,8 @@
 {
   /* Cursor data. */
   int datalen = 2;
-  int type, size;
+  int type;
+  gsize size;
 
   if (len < datalen) {
     GST_LOG_OBJECT (dec, "Cursor data too short");
@@ -405,9 +420,19 @@
   type = RFB_GET_UINT8 (data);
 
   if (type == CURSOR_COLOUR) {
-    datalen += rect->width * rect->height * dec->format.bytes_per_pixel * 2;
+    if (!vmnc_rect_payload_size (rect, dec->format.bytes_per_pixel, &size) ||
+        size > ((gsize) G_MAXINT - datalen) / 2) {
+      GST_WARNING_OBJECT (dec, "Cursor data size overflow");
+      return ERROR_INVALID;
+    }
+    datalen += size * 2;
   } else if (type == CURSOR_ALPHA) {
-    datalen += rect->width * rect->height * 4;
+    if (!vmnc_rect_payload_size (rect, 4, &size) ||
+        size > (gsize) G_MAXINT - datalen) {
+      GST_WARNING_OBJECT (dec, "Cursor data size overflow");
+      return ERROR_INVALID;
+    }
+    datalen += size;
   } else {
     GST_WARNING_OBJECT (dec, "Unknown cursor type: %d", type);
     return ERROR_INVALID;
@@ -422,22 +447,20 @@
   dec->cursor.type = type;
   dec->cursor.width = rect->width;
   dec->cursor.height = rect->height;
-  dec->cursor.type = type;
   dec->cursor.hot_x = rect->x;
   dec->cursor.hot_y = rect->y;
 
   g_free (dec->cursor.cursordata);
   g_free (dec->cursor.cursormask);
 
-  if (type == 0) {
-    size = rect->width * rect->height * dec->format.bytes_per_pixel;
+  if (type == CURSOR_COLOUR) {
     dec->cursor.cursordata = g_malloc (size);
     dec->cursor.cursormask = g_malloc (size);
     memcpy (dec->cursor.cursordata, data + 2, size);
     memcpy (dec->cursor.cursormask, data + 2 + size, size);
   } else {
-    dec->cursor.cursordata = g_malloc (rect->width * rect->height * 4);
-    memcpy (dec->cursor.cursordata, data + 2, rect->width * rect->height * 4);
+    dec->cursor.cursordata = g_malloc (size);
+    memcpy (dec->cursor.cursordata, data + 2, size);
     dec->cursor.cursormask = NULL;
   }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/meson.build -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/meson.build Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/po/gst-plugins-bad-1.0.pot -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/po/gst-plugins-bad-1.0.pot Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/po/gst-plugins-bad.pot -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/po/gst-plugins-bad.pot Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/release-notes-1.28.md -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/release-notes-1.28.md Changed

@@ -2,11 +2,11 @@
 
 GStreamer 1.28.0 was originally released on 27 January 2026.
 
-The latest bug-fix release in the stable 1.28 series is 1.28.3(#1.28.3) and was released on 11 May 2026.
+The latest bug-fix release in the stable 1.28 series is 1.28.5(#1.28.5) and was released on 08 July 2026.
 
 See https://gstreamer.freedesktop.org/releases/1.28/latest for the latest version of this document.
 
-*Last updated: Monday 11 May 2026, 16:00 UTC (log)gitlog*
+*Last updated: Wednesday 08 July 2026, 23:00 UTC (log)gitlog*
 
 latest: https://gstreamer.freedesktop.org/releases/1.28/
 gitlog: https://gitlab.freedesktop.org/gstreamer/www/commits/main/src/htdocs/releases/1.28/release-notes-1.28.md
@@ -2188,6 +2188,408 @@
 - List of Merge Requests applied in 1.28.3(https://gitlab.freedesktop.org/groups/gstreamer/-/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&milestone_title=1.28.3)
 - List of Issues fixed in 1.28.3(https://gitlab.freedesktop.org/groups/gstreamer/-/work_items?scope=all&utf8=%E2%9C%93&state=closed&milestone_title=1.28.3)
 
+<a id="1.28.4"></a>
+
+### 1.28.4
+
+The fourth 1.28 bug-fix release (1.28.4) was released on 12 June 2026.
+
+This release only contains bugfixes and important security fixessecurity.
+It *should* be safe to update from 1.28.x and we recommend you do so at your
+earliest convenience.
+
+security: https://gstreamer.freedesktop.org/security/
+
+#### Highlighted bugfixes in 1.28.4
+
+ - Various security fixessecurity and playback fixes
+ - audioaggregator: fixes for conversion of in-progress buffers when input caps change
+ - audioresample: more armv7 fixes
+ - camerabin: Fix caps negotiation failure when starting video capture
+ - Debug logging performance improvements
+ - fmp4mux: Fix draining in chunk mode after partial GOPs were drained
+ - gldownload: fix handling of directly imported dmabufs from glupload
+ - matroskamux: Write ReferenceBlock for non-keyframe video in BlockGroups
+ - rtp2: session: add "stats" property
+ - rtspsrc2: handle parse errors with TCP interleaved more gracefully where the server just drops data
+ - rtspsrc2: implement support for SRTP, authentication, HTTP tunnelling, keep alive, stream selection, TLS validation, latency configuration
+ - st2038combiner: only forward video pad segment, fixing issues for cases where the ST2038 segment differs
+ - Wavpack audio: Various channel and channel-mask related fixes
+ - webrtc, sdp: set level in negotiated caps only if level asymmetry not allowed, fixing an H.264 negotiation regression with higher resolutions
+ - androidmedia: add various new codec mime / profile mappings (WMV, VC1, AC3/EAC3/AC4, AAC, H265) and support decoding FLAC
+ - d3d12decoder: Fix decoding on Qualcomm GPUs on ARM64 Windows
+ - wasapi2src: fix hang when using loopback-target-pid (regression from 1.26)
+ - cerbero: update to Rust 1.96, plus glib-networking OpenSSL backend fixes
+ - Various bug fixes, build fixes, memory leak fixes, and other stability and reliability improvements
+
+#### gstreamer
+
+ - bufferpool: avoid leaking partially preallocated buffers(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11664)
+ - caps: fix multiple caps leaks(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11756)
+ - datetime: Improve correctness of ISO-8601 string parsing(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11616)
+ - info: Don't use fwrite() on Windows for debug logging(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11632)
+ - info: Use stack allocation for messages smaller than 1kB(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11624)
+ - task: Fix racy tests by making unref deterministic(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11638)
+ - value: fix crash when converting NULL G_TYPE_VALUE_ARRAY to G_TYPE_STRING(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11737)
+ - registry: detect libgstreamer load from Android container and skip canonicalization(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11612)
+ - tests: Fix build with glib <= 2.67.2(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11618)
+
+#### gst-plugins-base
+
+ - audio-resampler-neon: fix accumulated stride(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11703)
+ - audio-resampler-neon: re-increment address(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11760)
+ - audioaggregator: Remove brittle conversion of in-progress buffers(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11775)
+ - discoverer: Lock the DISCO_LOCK whenever accessing the streams list(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11840)
+ - gl: egl: Set TRANSFER_NEED_DOWNLOAD flag(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11710)
+ - gldownload: Can't handle directly imported dmabufs from glupload(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/4965)
+ - glupload: fix memleak on failure path(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11640)
+ - glwindow: Allow setting a NULL window handle(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11611)
+ - id3v2: Don't modify const data and check for enough data when reading RVA2 tags(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11808)
+ - id3v2: Don't unnecessarily assert on size==0 when unsyncing data(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11641)
+ - pbutils: Add NULL check for tmpcaps parsing(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11746)
+ - pbutils: Fix possible null dereference when empty string is provided(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11747)
+ - rtcpbuffer: Add some missing bounds checks when parsing SDES(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11796)
+ - sdp: keep level-asymmetry-allowed in the caps(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11727)
+ - subparse: Avoid zero and extreme fps when parsing mdvdsub subtitles(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11810)
+ - uridecodebin3: Use PLAY_ITEMS_LOCK for URI-related getter(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11633)
+ - uridecodebin: Protect missing_plugin_errors list from concurrent access(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11615)
+ - videodmabufpool: Fix debug category(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11677)
+ - xmptag: Correctly initialize pointer to the end of the input array(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11806)
+
+#### gst-plugins-good
+
+ - matroska-mux: Write ReferenceBlock for non-keyframe video in BlockGroups(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11722)
+ - osxaudio: Fix stack overflow with >64ch audio devices(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11658)
+ - qtdemux: parse mastering luminance as u32 instead of u16(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11661)
+ - qt6: remove an unneeded QOpenGLContext->makeCurrent()(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11833)
+ - rtph265depay: fix memory leak(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11715)
+ - sbcparse: Add bounds checking to header parsing(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11817)
+ - tests: mpegaudioparse: Fix raciness in the state change handling(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11724)
+ - v4l2: Fix buffer leak on qbuf failure(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11759)
+ - wavpack: Various channel / channel-mask related fixes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11757)
+ - wavpackdec: Avoid integer overflow when calculating output buffer size and related fixes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11811)
+ - wavpackenc fails for channels > 2(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5129)
+
+#### gst-plugins-bad
+
+ - ahcsrc: Register exposure-mode property for GstPhotography interface(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11613)
+ - amc: Don't try printing NULL caps(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11688)
+ - amcvideodec: Don't keep crop-rectangle uninitialized if not specified(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11686)
+ - androidmedia: Add various new codec mime / profile mappings(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11614)
+ - androidmedia: Don't print error logs if downstream returns flushing / EOS(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11610)
+ - androidmedia: Fix typo in error message(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11692)
+ - androidmedia: support decoding flac(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11647)
+ - av1parser: Fix bytes/bits confusion when parsing tile data size(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11827)
+ - camerabin: Fix caps negotiation when starting video capture(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11774)
+ - d3d12decoder: Fix decoding on Qualcomm GPUs(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11781)
+ - mpegtspacketizer: Do not seek before the first PCR(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11786)
+ - mxfdemux: Use unsigned integers in more places and don't truncate 64 bit integers(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11837)
+ - svtav1enc: Scale MDCV and CLL to SVT-AV1's expected units(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11609)
+ - va: drm: Fix fd leak and return type in create_va_display(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11642)
+ - vajpegdecoder: Validate that enough data is available for the current JPEG segment(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11834)
+ - vulkanupload: Don't reallocate the pool when the framerate changes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11628)
+ - wasapi2: Don't reset process loopback capture client(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11683)
+ - wasapi2src hangs when using loopback-target-pid in GStreamer 1.28 (regression from 1.26)(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/4878)
+ - tests: Fix build with glib <= 2.67.2(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11618)
+ - meson: fix building -bad tests with disabled mse(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11617)
+
+#### gst-plugins-ugly
+
+ - realmedia: Fixes for various out-of-bounds reads(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11826)
+
+#### GStreamer Rust plugins
+
+ - fmp4mux: Fix draining in chunk mode after partial GOPs were drained(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3062)
+ - Rtp2Session: add ParamSpec for property stats(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3061)
+ - rtspsrc2: Add support for SET_PARAMETER and GET_PARAMETER using signals(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3095)
+ - rtspsrc2: Add support for SRTP(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3086)
+ - rtspsrc2: Add TLS support(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3064)
+ - rtspsrc2: handle parse errors with tcp interleaved rtsp more gracefully(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3077)
+ - rtspsrc2: Implement authentication support(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3063)
+ - rtspsrc2: Implement support for HTTP tunnelling(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3065)
+ - rtspsrc2: Implement support for keep alive(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3066)
+ - rtspsrc2: Implement support for streams(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3078)
+ - rtspsrc2: Include user-agent property in HTTP tunnel requests(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3067)
+ - rtspsrc2: Support TLS validation flags for server certificate(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3104)
+ - rtspsrc2: Support latency configuration property(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3100)
+ - rtspsrc2: Update README with implemented features(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3069)
+ - st2038combiner: only forward video pad segment(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3097)
+ - webrtc: set level in negotiated caps only if level asymmetry not allowed(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3089)
+ - webrtcsink: handle payloader timestamp-offset prop type variants(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3081)
+ - webrtcsrc, webrtcsink: Fix SDP renegotiation bugs(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3098)
+ - Added script to convert git sourced dependencies to crates.io packages(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3084)
+ - gst-plugin-version-helper: Relax version requirements and update to 0.8.4(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3072)
+
+#### gst-libav
+
+ - avdemux: Always free AVIOContext and open failure and don't dereference NULL AVFormatContext(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11823)
+ - avprotocol: Don't free GstFFMpegPipe when closing the AVIOContext(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11820)
+
+#### gst-rtsp-server
+
+ - RTSPMediaFactory: make create_pipeline virtual method introspectable(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11726)
+
+#### gstreamer-sharp
+
+ - No changes
+
+#### gst-python
+
+ - No changes
+
+#### gst-editing-services
+
+ - No changes
+
+#### gst-devtools, gst-validate + gst-integration-testsuites
+
+ - use relative paths in the printed validate command, fix flaky tests due to non-deterministic pad task unref(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11646)
+
+#### gst-examples
+
+ - No changes
+
+#### gstreamer-docs
+
+ - No changes
+
+#### Development build environment
+
+ - AGENTS.md: Add explicit exception for including tool output in issue descriptions(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11728)
+
+#### Cerbero build tool and packaging changes in 1.28.4
+
+ - Update to Rust 1.96 / cargo-c 0.10.23(https://gitlab.freedesktop.org/gstreamer/cerbero/-/merge_requests/2261)
+ - Read recipe files as UTF-8(https://gitlab.freedesktop.org/gstreamer/cerbero/-/merge_requests/2263)
+ - glib-networking: Backport various OpenSSL backend fixes(https://gitlab.freedesktop.org/gstreamer/cerbero/-/merge_requests/2251)
+ - pkg-config.recipe: Never enable --define-prefix(https://gitlab.freedesktop.org/gstreamer/cerbero/-/merge_requests/2259)
+ - source: serialize tarball extracts that share an unpack path(https://gitlab.freedesktop.org/gstreamer/cerbero/-/merge_requests/2252)
+
+#### Contributors to 1.28.4
+
+Albert Sjölund, Arthur Chan, Carlos Falgueras García, Cheah, Vincent Beng Keat,
+dec05eba, Dino Spiller, Edward Hervey, François Laignel, Gordon Smith, Hou Qi,
+Jakub Adam, Jan Alexander Steffens (heftig), Jan Schmidt, L. E. Segovia,
+Marcus Hanestad, Mathieu Duponchelle, Matthew Waters, Niclas Götting,
+Nirbheek Chauhan, Piotr Brzeziński, Qian Hu (胡骞), Rares Branici, Robert Mader,
+Sanchayan Maity, Sebastian Dröge, Seungha Yang, Seungmin Lee, Stéphane Cerveau,
+Suhwan Choi, Taruntej Kanakamalla, Tim-Philipp Müller, Víctor Manuel Jáquez Leal,
+Vivia Nikolaidou, Xavier Claessens,
+
+... 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.28.4
+
+- List of Merge Requests applied in 1.28.4(https://gitlab.freedesktop.org/groups/gstreamer/-/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&milestone_title=1.28.4)
+- List of Issues fixed in 1.28.4(https://gitlab.freedesktop.org/groups/gstreamer/-/work_items?scope=all&utf8=%E2%9C%93&state=closed&milestone_title=1.28.4)
+
+<a id="1.28.5"></a>
+
+### 1.28.5
+
+The fifth 1.28 bug-fix release (1.28.5) was released on 08 July 2026.
+
+This release only contains bugfixes and important security fixessecurity.
+It *should* be safe to update from 1.28.x and we recommend you do so at your
+earliest convenience.
+
+security: https://gstreamer.freedesktop.org/security/
+
+#### Highlighted bugfixes in 1.28.5
+
+ - Various security fixessecurity and playback fixes
+ - Fix subtitles cause green flickering with VA decoders on AMD GPUs
+ - core: Fix sticky event raciness when pads are linked mid-push
+ - appsrc: Uniformly handle EOS events being pushed
+ - audio-resampler-neon fails to build for targets with neon but without thumb
+ - avtp: Correct ptime generation from avtp timestamp
+ - fmp4mux: Various fixes for splitting at fragment boundaries
+ - gldownload: fix wrong DRM format negotiation causing R/B channel swap
+ - gdkpixbufdec: Drop rank to NONE and handle resolution/format changes
+ - gopbuffer: add support for H.266/VVC
+ - h265decoder: Fix HEVC with alpha decoding
+ - mp4mux: fix AC-3 template caps so muxer can accept input from ac3parse
+ - mpegtsmux: Always assign PTS to output buffers in CBR mode
+ - mpegtsmux: Output buffers with PCR-only bitrate-padding packets have wrong PTS
+ - rtcpbuffer: Fix parsing of SR+SDES compound packets (regression from security fix)
+ - rtspsrc2: Allow disabling SRTP/SRTCP encryption and SRTP authentication
+ - tsdemux: Improve PTS rollover handling in ignore-pcr mode, fixing intermittent corruption with YouTube HLS streams 
+ - textaccumulate: output joined single buffer, add list as meta
+ - threadshare: add ts-clocksync
+ - webrtcsink: negotiation fixes and improvements
+ - Various bug fixes, build fixes, memory leak fixes, and other stability and reliability improvements
+
+#### gstreamer
+
+ - caps: fix field name leak in gst_caps_structure_simplify(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11914)
+ - info: Use a more optimized version of GST_TIME_ARGS(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11995)
+ - pads: Fix sticky event raciness when linked mid-push(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11948)
+ - typefindhelper: Drop unnecessary check for factories without a function(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12020)
+ - Use named pipes when spawning gst-ptp-helper on Windows(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11994)
+
+#### gst-plugins-base
+
+ - appsink: Clear local sample storage when flushing(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11947)
+ - appsrc: Uniformly handle EOS events being pushed(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11925)
+ - audio-resampler-neon fails to build for targets with neon but without thumb(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5164)
+ - encoding-target: Validate that encoding profile name is UTF-8 before using it(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12068)
+ - gldownload: fix wrong DRM format negotiation causing R/B channel swap(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11997)
+ - opusdec: Don't use any channel positions for >64 channels(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12067)
+ - rtcpbuffer: Fix parsing of SR+SDES compound packets (regression from security fix)(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12033)
+ - subparse: Don't allow very small framerates for microdvd subtitles(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11852)
+ - typefind: assorted fixes for the image-rs plugin typefinding(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11972)
+ - typefindhelper: Drop unnecessary check for factories without a function(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12020)
+ - WBMP typefinding rejects a valid 1280x800 file(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5001)
+ - typefinding: detect animation on PNG (and WebP, GIF, AVIF)(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/4986)
+ - typefindfunctions: remove Sun and Andrew raster format typefinders(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11901)
+ - uridecodebin3: deactivate input_item in erroneous ready->paused transition(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11952)
+ - vorbistag: Check for enough base64 data before trying to decode(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11856)
+ - xmptag: Don't allocate -1 bytes of memory if there's only a single tag(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11853)
+ - xmptag: Handle fractions with 0 denominator as invalid(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11922)
+
+#### gst-plugins-good
+
+ - flacenc: Fix g_object_notify on loose-mid-side-stereo property(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11860)
+ - gdkpixbufdec: Drop rank to NONE and handle resolution/format changes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12060)
+ - gdkpixbufdec: stop advertising Sun and Andrew raster formats(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11901)
+ - gdkpixbufdec announces unsupported raster mediatypes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5004)
+ - matroskademux: Don't pass non-GstElement pointers to GST_ELEMENT_ERROR(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11918)
+ - matroska: Update lzo decompression implementation from latest ffmpeg(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12079)
+ - mp4mux: fix AC-3 template caps so muxer can accept input from ac3parse(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12028)
+ - pngdec: fix wrong macro being used for ICC support test(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11972)
+ - qtmoovrecover: Validate box sizes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12058)
+ - rtpceltdepay: error out if anyone tries to use this element(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12039)
+ - rtpjpegdepay: Ensure that quantization table is big enough(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12071)
+ - rtpsbcdepay: Check for available data in the adapter before getting data(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12059)
+ - shapewipe: Fix missing mutex unlock in shutdown path(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12016)
+ - wavparse: Avoid NULL pointer dereference when parsing adtl in push mode(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12078)
+
+#### gst-plugins-bad
+
+ - amcviddec: Fix double-free happening when codec gets reconfigured(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11902)
+ - avtp: Correct ptime generation from avtp timestamp(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11934)
+ - ccconverter: Use truncated length when converting CEA608 raw to CEA708 CDP(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12074)
+ - curlsmtpsink: Use the correct content-type if known(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11991)
+ - d3d12: Fix command list leak(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12006)
+ - dtlsconnection: Allocate large enough buffer for the peer certificate subject DN(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12076)
+ - h264parse: Check for enough slice header data being available(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11941)
+ - h2654parse: Unset GValue in every code path(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11921)
+ - h265decoder: Fix HEVC with alpha decoding(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11916)
+ - h266parser: Avoid out-of-bounds read if too many exp slices are signalled(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12069)
+ - h266parser: Check bounds before writing to CTU entrypoint array(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12070)
+ - h266parser: Check aspect ratio index against lookup table length(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11942)
+ - h266parser: Heap-allocate parameter sets before parse to avoid stack overflow(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11990)
+ - h266parser: Use long bit skipping function for potentially large values(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11920)
+ - mpeg4videoparse: Ensure enough config data is available before extracting profile/level(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12057)
+ - mpegpsdemux: Release stream lock when seeking fails(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11871)
+ - mpegtsmux: Always assign PTS to output buffers in CBR mode(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11955)
+ - mpegtsmux: Output buffers with PCR-only bitrate-padding packets have wrong PTS(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5151)
+ - mxfdemux: fix essence track offsets array population(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11892)
+ - netsim: Fix racy test failures(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11933)
+ - pcapparse: Add missing bounds checks to ensure packets are large enough(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11874)
+ - pnmdec: Avoid overflows when calculating frame sizes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11926)
+ - qroverlay: Fix use after free bug(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11960)
+ - rfbsrc: Use correct bpp for copying hextile data(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12077)
+ - rfbsrc: Validate framebuffer update rectangles against the framebuffer size(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11868)
+ - rtmp2: Don't retry on G_IO_ERROR_TIMED_OUT(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11889)
+ - rtmp2: Remove socket timeout after handshake completes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11890)
+ - rtpsink: fix mutex not unlocked on invalid URI in set_property(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11949)
+ - tsdemux: YouTube HLS streams have intermittent corruption(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5141)
+ - tsdemux: Improve PTS rollover handling in ignore-pcr mode(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11905)
+ - v4l2decoder: Fix media_fd leak when video_fd open fails(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11999)
+ - va: surfacecopy: get surface's image in `gst_va_surface_copy`(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11935)
+ - va: VOBSUB: compositing error with VA decoder in NV12(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5014)
+ - va: radeonsi: subtitles cause green flickering(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/3906)
+ - va: radeonsi: Subtitles cause green flickering with VA decoders(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5165)
+ - videoparsers: Always clear LCEVC enhancement data when resetting frame(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11987)
+ - videoparsers: Leak of LCEVC user data(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/work_items/5192)
+ - vnmdec: Avoid integer overflows when rectangle positions and sizes(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11876)
+ - vp9parser: Check that enough data is available for parsing superframe info(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12073)
+ - webrtcbin: validate remote dtls certificates(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/11963)
+ - webrtcsdp: Fix inverted fingerprint existence logic(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12075)
+
+#### gst-plugins-ugly
+
+ - asfdemux: Ensure that enough data is available for reading all replicated extensions(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12072)
+
+#### GStreamer Rust plugins
+
+ - fmp4mux: Various fixes for splitting at fragment boundaries(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3130)
+ - gopbuffer: add support for H.266/VVC(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3138)
+ - onvifmeta2relatiometa: fix inversion between width and height(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3110)
+ - rtprecv: fix buffer list split handling(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3115)
+ - rtspsrc2: digest authentication fixes(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3139)
+ - rtspsrc2: Allow disabling SRTP/SRTCP encryption and SRTP authentication(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3148)
+ - textaccumulate: output joined single buffer, add list as meta(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3150)
+ - threadshare: add ts-clocksync(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3136)
+ - webrtcsink: add support for h264 profile constrained-high(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3126)
+ - webrtcsink: allow change of interlace-mode in the input caps(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3129)
+ - webrtcsink: allow renegotiation if caps is missing interlace-mode(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3128)
+ - webrtcsink: fix negotiation for nvh264enc in the GLMemory case(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3134)
+ - webrtcsink: read rav1enc bitrate as i32(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3113)
+ - webrtcsrc, webrtcsink: Fix SDP renegotiation bugs(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3098)
+ - Update dependencies(https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/3142)
+
+#### gst-libav
+
+ - No changes
+
+#### gst-rtsp-server
+
+ - No changes
+
+#### gstreamer-sharp
+
+ - No changes
+
+#### gst-python
+
+ - No changes
+
+#### gst-editing-services
+
+ - tests: Implement assertion check macros as functions to speed up compilation(https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/12012)
+
+#### gst-devtools, gst-validate + gst-integration-testsuites
+
+ - No changes
+
+#### gst-examples
+
+ - No changes
+
+#### gstreamer-docs
+
+ - No changes
+
+#### Development build environment
+
+ - No changes
+
+#### Cerbero build tool and packaging changes in 1.28.5
+
+ - No changes
+
+#### Contributors to 1.28.5
+
+Alexei Walisiewicz, Amy Ko, Arthur Chan, Benoît Mauduit, Christopher Meltzer,
+Christoph Seitz, Daniel Morin, Diego Nieto, Dominique Leroux, Erik Strandh,
+François Laignel, Gordon Smith, Jan Alexander Steffens (heftig), Jan Schmidt,
+Jeehyun Lee, Jerome Colle, Julian Bouzas, L. E. Segovia, Marcus Hanestad,
+Mathieu Duponchelle, Matthew Waters, Nirbheek Chauhan, Pablo García,
+Philippe Normand, Piotr Brzeziński, Qi Hou, Sanchayan Maity, Sebastian Dröge,
+Seungha Yang, Taruntej Kanakamalla, Thibault Saunier, Tim-Philipp Müller,
+Tomas Granath, Víctor Manuel Jáquez Leal, Xavier Claessens,
+
+... 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.28.5
+
+- List of Merge Requests applied in 1.28.5(https://gitlab.freedesktop.org/groups/gstreamer/-/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&milestone_title=1.28.5)
+- List of Issues fixed in 1.28.5(https://gitlab.freedesktop.org/groups/gstreamer/-/work_items?scope=all&utf8=%E2%9C%93&state=closed&milestone_title=1.28.5)
+
 ## Schedule for 1.30
 
 Our next major feature release will be 1.30, and 1.29 will be the unstable

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/androidmedia/gstahcsrc.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/androidmedia/gstahcsrc.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/androidmedia/gstamc-constants.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/androidmedia/gstamc-constants.h Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/androidmedia/gstamc.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/androidmedia/gstamc.c Changed

@@ -1138,7 +1138,8 @@
       HEVCProfileMain, "main"}, {
       HEVCProfileMain10, "main-10"}, {
       HEVCProfileMain10HDR10, "main-10"}, {
-      HEVCProfileMain10HDR10Plus, "main-10"}
+      HEVCProfileMain10HDR10Plus, "main-10"}, {
+      HEVCProfileMainStill, "main-still-picture"}
 };
 
 const gchar *
@@ -1527,7 +1528,10 @@
       AACObjectMain, "main"}, {
       AACObjectLC, "lc"}, {
       AACObjectSSR, "ssr"}, {
-      AACObjectLTP, "ltp"}
+      AACObjectLTP, "ltp"},
+  {AACObjectLD, "ld"},
+  {AACObjectHE, "he-aac-v1"},
+  {AACObjectHE_PS, "he-aac-v2"},
 };
 
 const gchar *
@@ -2158,6 +2162,14 @@
               "channels", GST_TYPE_INT_RANGE, 1, G_MAXINT,
               "framed", G_TYPE_BOOLEAN, TRUE, NULL);
           encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
+        } else if (strcmp (type->mime, "audio/mpeg-L1") == 0) {
+          tmp = gst_structure_new ("audio/mpeg",
+              "mpegversion", G_TYPE_INT, 1,
+              "layer", G_TYPE_INT, 1,
+              "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+              "channels", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+              "parsed", G_TYPE_BOOLEAN, TRUE, NULL);
+          encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
         } else if (strcmp (type->mime, "audio/mpeg-L2") == 0) {
           tmp = gst_structure_new ("audio/mpeg",
               "mpegversion", G_TYPE_INT, 1,
@@ -2166,6 +2178,22 @@
               "channels", GST_TYPE_INT_RANGE, 1, G_MAXINT,
               "parsed", G_TYPE_BOOLEAN, TRUE, NULL);
           encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
+        } else if (strcmp (type->mime, "audio/ac3") == 0) {
+          tmp = gst_structure_new ("audio/x-ac3",
+              "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+              "channels", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+              "framed", G_TYPE_BOOLEAN, TRUE, NULL);
+          encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
+        } else if (strcmp (type->mime, "audio/eac3") == 0) {
+          tmp = gst_structure_new ("audio/x-eac3",
+              "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+              "channels", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+              "framed", G_TYPE_BOOLEAN, TRUE, NULL);
+          encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
+        } else if (strcmp (type->mime, "audio/ac4") == 0) {
+          tmp = gst_structure_new ("audio/x-ac4",
+              "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+              "channels", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);
         } else {
           GST_WARNING ("Unsupported mimetype '%s'", type->mime);
         }
@@ -2202,7 +2230,8 @@
       }
 
       if (encoded_ret) {
-        if (strcmp (type->mime, "video/mp4v-es") == 0) {
+        if (strcmp (type->mime, "video/mp4v-es") == 0
+            || strcmp (type->mime, "video/mp43") == 0) {
           gint j;
           gboolean have_profile_level = FALSE;
 
@@ -2534,6 +2563,39 @@
               "parsed", G_TYPE_BOOLEAN, TRUE, NULL);
 
           encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
+        } else if (strcmp (type->mime, "video/wvc1") == 0) {
+          tmp = gst_structure_new ("video/x-wmv",
+              "width", GST_TYPE_INT_RANGE, 16, 4096,
+              "height", GST_TYPE_INT_RANGE, 16, 4096,
+              "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1,
+              "format", G_TYPE_STRING, "WVC1", NULL);
+
+          encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
+        } else if (strcmp (type->mime, "video/x-ms-wmv") == 0) {
+          tmp = gst_structure_new ("video/x-wmv",
+              "width", GST_TYPE_INT_RANGE, 16, 4096,
+              "height", GST_TYPE_INT_RANGE, 16, 4096,
+              "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1,
+              "format", G_TYPE_STRING, "WMV3",
+              "wmvversion", G_TYPE_INT, 3, NULL);
+
+          encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
+        } else if (strcmp (type->mime, "video/x-ms-wmv8") == 0) {
+          tmp = gst_structure_new ("video/x-wmv",
+              "width", GST_TYPE_INT_RANGE, 16, 4096,
+              "height", GST_TYPE_INT_RANGE, 16, 4096,
+              "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1,
+              "wmvversion", G_TYPE_INT, 2, NULL);
+
+          encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
+        } else if (strcmp (type->mime, "video/x-ms-wmv7") == 0) {
+          tmp = gst_structure_new ("video/x-wmv",
+              "width", GST_TYPE_INT_RANGE, 16, 4096,
+              "height", GST_TYPE_INT_RANGE, 16, 4096,
+              "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1,
+              "wmvversion", G_TYPE_INT, 1, NULL);
+
+          encoded_ret = gst_caps_merge_structure (encoded_ret, tmp);
         } else {
           GST_WARNING ("Unsupported mimetype '%s'", type->mime);
         }
@@ -2546,16 +2608,20 @@
     guint i, n;
     GST_LOG ("Returning caps for '%s':", codec_info->name);
 
-    GST_LOG (" raw caps:");
-    n = gst_caps_get_size (raw_ret);
-    for (i = 0; i < n; i++) {
-      GST_LOG ("  %" GST_PTR_FORMAT, gst_caps_get_structure (raw_ret, i));
+    if (raw_ret) {
+      GST_LOG (" raw caps:");
+      n = gst_caps_get_size (raw_ret);
+      for (i = 0; i < n; i++) {
+        GST_LOG ("  %" GST_PTR_FORMAT, gst_caps_get_structure (raw_ret, i));
+      }
     }
 
-    GST_LOG (" encoded caps:");
-    n = gst_caps_get_size (encoded_ret);
-    for (i = 0; i < n; i++) {
-      GST_LOG ("  %" GST_PTR_FORMAT, gst_caps_get_structure (encoded_ret, i));
+    if (encoded_ret) {
+      GST_LOG (" encoded caps:");
+      n = gst_caps_get_size (encoded_ret);
+      for (i = 0; i < n; i++) {
+        GST_LOG ("  %" GST_PTR_FORMAT, gst_caps_get_structure (encoded_ret, i));
+      }
     }
   }
 }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/androidmedia/gstamcaudiodec.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/androidmedia/gstamcaudiodec.c Changed

@@ -141,6 +141,8 @@
 
       if (!gst_structure_get_int (s, "layer", &layer) || layer == 3)
         return "audio/mpeg";
+      else if (layer == 1)
+        return "audio/mpeg-L1";
       else if (layer == 2)
         return "audio/mpeg-L2";
     } else if (mpegversion == 2 || mpegversion == 4) {
@@ -158,6 +160,14 @@
     return "audio/vorbis";
   } else if (strcmp (name, "audio/x-opus") == 0) {
     return "audio/opus";
+  } else if (strcmp (name, "audio/x-flac") == 0) {
+    return "audio/flac";
+  } else if (strcmp (name, "audio/x-ac3") == 0) {
+    return "audio/ac3";
+  } else if (strcmp (name, "audio/x-eac3") == 0) {
+    return "audio/eac3";
+  } else if (strcmp (name, "audio/x-ac4") == 0) {
+    return "audio/ac4";
   }
 
   return NULL;
@@ -1204,8 +1214,14 @@
 
 downstream_error:
   {
-    GST_ERROR_OBJECT (self, "Downstream returned %s",
-        gst_flow_get_name (self->downstream_flow_ret));
+    if (self->downstream_flow_ret == GST_FLOW_NOT_LINKED
+        || self->downstream_flow_ret < GST_FLOW_EOS) {
+      GST_ERROR_OBJECT (self, "Downstream returned %s",
+          gst_flow_get_name (self->downstream_flow_ret));
+    } else {
+      GST_DEBUG_OBJECT (self, "Downstream returned %s",
+          gst_flow_get_name (self->downstream_flow_ret));
+    }
     if (minfo.data)
       gst_buffer_unmap (inbuf, &minfo);
     if (inbuf)

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/androidmedia/gstamcvideodec.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/androidmedia/gstamcvideodec.c Changed

@@ -327,6 +327,23 @@
     return "video/av01";
   } else if (strcmp (name, "video/x-divx") == 0) {
     return "video/mp4v-es";
+  } else if (strcmp (name, "video/x-wmv") == 0) {
+    const gchar *format;
+    gint wmvversion = -1;
+
+    gst_structure_get_int (s, "wmvversion", &wmvversion);
+    format = gst_structure_get_string (s, "format");
+    if (wmvversion == 1)
+      return "video/x-ms-wmv7";
+    else if (wmvversion == 2)
+      return "video/x-ms-wmv8";
+    else if (wmvversion == 3)
+      return "video/x-ms-wmv";
+
+    if (!format || strcmp (format, "WMV3") == 0)
+      return "video/x-ms-wmv";
+    else if (strcmp (format, "WVC1") == 0)
+      return "video/wvc1";
   }
 
   return NULL;
@@ -744,8 +761,8 @@
   const gchar *mime;
   gint color_format, width, height;
   gint stride, slice_height;
-  gint crop_left, crop_right;
-  gint crop_top, crop_bottom;
+  gint crop_left = 0, crop_right = 0;
+  gint crop_top = 0, crop_bottom = 0;
   GstVideoFormat gst_format;
   GstAmcVideoDecClass *klass = GST_AMC_VIDEO_DEC_GET_CLASS (self);
   GError *err = NULL;
@@ -1776,7 +1793,7 @@
   self->draining = FALSE;
   g_cond_broadcast (&self->drain_cond);
   g_mutex_unlock (&self->drain_lock);
-  g_free (self->codec_data);
+  g_clear_pointer (&self->codec_data, g_free);
   self->codec_data_size = 0;
   if (self->input_state)
     gst_video_codec_state_unref (self->input_state);
@@ -2242,8 +2259,14 @@
 
 downstream_error:
   {
-    GST_ERROR_OBJECT (self, "Downstream returned %s",
-        gst_flow_get_name (self->downstream_flow_ret));
+    if (self->downstream_flow_ret == GST_FLOW_NOT_LINKED
+        || self->downstream_flow_ret < GST_FLOW_EOS) {
+      GST_ERROR_OBJECT (self, "Downstream returned %s",
+          gst_flow_get_name (self->downstream_flow_ret));
+    } else {
+      GST_DEBUG_OBJECT (self, "Downstream returned %s",
+          gst_flow_get_name (self->downstream_flow_ret));
+    }
     if (minfo.data)
       gst_buffer_unmap (frame->input_buffer, &minfo);
     gst_video_codec_frame_unref (frame);

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/androidmedia/gstamcvideoenc.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/androidmedia/gstamcvideoenc.c Changed

@@ -233,6 +233,22 @@
     mime = "video/x-vnd.on2.vp9";
   } else if (strcmp (name, "video/x-av1") == 0) {
     mime = "video/av01";
+  } else if (strcmp (name, "video/x-wmv") == 0) {
+    const gchar *format;
+    gint wmvversion = -1;
+
+    gst_structure_get_int (s, "wmvversion", &wmvversion);
+    format = gst_structure_get_string (s, "format");
+    if (wmvversion == 1)
+      mime = "video/x-ms-wmv7";
+    else if (wmvversion == 2)
+      mime = "video/x-ms-wmv8";
+    else if (wmvversion == 3)
+      mime = "video/x-ms-wmv";
+    else if (!format || strcmp (format, "WMV3") == 0)
+      mime = "video/x-ms-wmv";
+    else if (strcmp (format, "WVC1") == 0)
+      mime = "video/wvc1";
   } else {
     GST_ERROR_OBJECT (encoder, "Failed to convert caps(%s/...) to any mime",
         name);
@@ -1677,8 +1693,14 @@
 
 downstream_error:
   {
-    GST_ERROR_OBJECT (self, "Downstream returned %s",
-        gst_flow_get_name (self->downstream_flow_ret));
+    if (self->downstream_flow_ret == GST_FLOW_NOT_LINKED
+        || self->downstream_flow_ret < GST_FLOW_EOS) {
+      GST_ERROR_OBJECT (self, "Downstream returned %s",
+          gst_flow_get_name (self->downstream_flow_ret));
+    } else {
+      GST_DEBUG_OBJECT (self, "Downstream returned %s",
+          gst_flow_get_name (self->downstream_flow_ret));
+    }
 
     gst_video_codec_frame_unref (frame);
     return self->downstream_flow_ret;

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/androidmedia/ndk/gstamc-codec-ndk.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/androidmedia/ndk/gstamc-codec-ndk.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/d3d12/gstd3d12decoder.cpp -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/d3d12/gstd3d12decoder.cpp Changed

@@ -95,11 +95,13 @@
 class GstD3D12Dpb
 {
 public:
-  GstD3D12Dpb (guint8 size) : size_(size)
+  GstD3D12Dpb (guint8 size, bool array_of_textures)
   {
+    size_ = size;
     textures_.resize (size);
     subresources_.resize (size);
     heaps_.resize (size);
+    array_of_textures_ = array_of_textures;
 
     for (guint i = 0; i < size; i++) {
       dxva_id_.push (i);
@@ -111,20 +113,24 @@
 
   guint8 Acquire (GstD3D12Memory * mem, ID3D12VideoDecoderHeap * heap)
   {
-    std::unique_lock <std::mutex> lk (lock_);
-    while (dxva_id_.empty ())
-      cond_.wait (lk);
-
-    guint8 ret = dxva_id_.front ();
-    dxva_id_.pop ();
-
-    GstD3D12Memory *dmem;
     ID3D12Resource *resource;
     UINT subresource = 0;
 
-    dmem = GST_D3D12_MEMORY_CAST (mem);
-    resource = gst_d3d12_memory_get_resource_handle (dmem);
-    gst_d3d12_memory_get_subresource_index (dmem, 0, &subresource);
+    resource = gst_d3d12_memory_get_resource_handle (mem);
+    gst_d3d12_memory_get_subresource_index (mem, 0, &subresource);
+
+    guint8 ret = 0;
+    if (array_of_textures_) {
+      std::unique_lock <std::mutex> lk (lock_);
+      while (dxva_id_.empty ())
+        cond_.wait (lk);
+
+      ret = dxva_id_.front ();
+      dxva_id_.pop ();
+    } else {
+      /* Use subresource index directly when texture array is in use */
+      ret = (guint8) subresource;
+    }
 
     textures_ret = resource;
     subresources_ret = subresource;
@@ -142,7 +148,8 @@
       return;
     }
 
-    dxva_id_.push (id);
+    if (array_of_textures_)
+      dxva_id_.push (id);
     textures_id = nullptr;
     subresources_id = 0;
     heaps_id = nullptr;
@@ -177,6 +184,7 @@
   std::vector<UINT> subresources_;
   std::vector<ID3D12VideoDecoderHeap *> heaps_;
   bool flushing = false;
+  bool array_of_textures_ = false;
 };
 
 struct GstD3D12DecoderPicture : public GstMiniObject
@@ -792,7 +800,8 @@
 
   gst_caps_unref (caps);
 
-  session->dpb = std::make_shared < GstD3D12Dpb > ((guint8) session->dpb_size);
+  session->dpb = std::make_shared < GstD3D12Dpb > ((guint8) session->dpb_size,
+      session->array_of_textures);
 
   priv->session = std::move (session);
   priv->last_flow = GST_FLOW_OK;
@@ -1167,6 +1176,10 @@
     out_args.ConversionArguments.Enable = TRUE;
     out_args.ConversionArguments.pReferenceTexture2D = resource;
     out_args.ConversionArguments.ReferenceSubresource = subresource0;
+    out_args.ConversionArguments.DecodeColorSpace =
+        DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709;
+    out_args.ConversionArguments.OutputColorSpace =
+        out_args.ConversionArguments.DecodeColorSpace;
   } else {
     out_args.pOutputTexture2D = resource;
     out_args.OutputSubresource = subresource0;

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/v4l2codecs/gstv4l2decoder.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/v4l2codecs/gstv4l2decoder.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/va/gstjpegdecoder.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/va/gstjpegdecoder.c Changed

@@ -370,6 +370,18 @@
 }
 #endif
 
+static gboolean
+jpeg_segment_fits_input (const GstJpegSegment * seg, gsize size)
+{
+  if (seg->size < 0)
+    return FALSE;
+
+  if ((gsize) seg->offset > size)
+    return FALSE;
+
+  return (gsize) seg->size <= size - (gsize) seg->offset;
+}
+
 static GstFlowReturn
 gst_jpeg_decoder_handle_frame (GstVideoDecoder * decoder,
     GstVideoCodecFrame * frame)
@@ -399,6 +411,9 @@
     if (!gst_jpeg_parse (&seg, map.data, map.size, offset))
       goto unmap_and_error;
 
+    if (!jpeg_segment_fits_input (&seg, map.size))
+      goto unmap_and_error;
+
     offset = seg.offset + seg.size;
     marker = seg.marker;
 
@@ -445,6 +460,9 @@
           if (!gst_jpeg_parse (&seg_scan, map.data, map.size, offset))
             goto unmap_and_error;
 
+          if (!jpeg_segment_fits_input (&seg_scan, map.size))
+            goto unmap_and_error;
+
           if (seg_scan.marker < GST_JPEG_MARKER_RST_MIN
               || seg_scan.marker > GST_JPEG_MARKER_RST_MAX)
             break;

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/va/gstvafilter.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/va/gstvafilter.c Changed

@@ -1790,6 +1790,17 @@
   return TRUE;
 }
 
+gboolean
+gst_va_filter_supports_premultiplied_alpha (GstVaFilter * self)
+{
+  g_return_val_if_fail (GST_IS_VA_FILTER (self), FALSE);
+
+  if (!gst_va_filter_is_open (self))
+    return FALSE;
+
+  return self->pipeline_caps.blend_flags & VA_BLEND_PREMULTIPLIED_ALPHA;
+}
+
 /**
  * gst_va_filter_compose:
  * @tx: the #GstVaComposeTransaction for input samples and output.
@@ -1838,7 +1849,10 @@
     VAProcPipelineParameterBuffer params = { 0, };
     VABufferID buffer;
     VASurfaceID in_surface;
-    VABlendState blend = { 0, };
+    VABlendState blend = {
+      .flags = 0,
+      .global_alpha = 1.0,
+    };
 
     in_surface = _get_surface_from_buffer (self, sample->buffer);
     if (in_surface == VA_INVALID_ID)
@@ -1862,12 +1876,14 @@
     /* only send blend state when sample is not fully opaque */
     if ((self->pipeline_caps.blend_flags & VA_BLEND_GLOBAL_ALPHA)
         && sample->alpha < 1.0) {
-      /* *INDENT-OFF* */
-      blend = (VABlendState) {
-        .flags = VA_BLEND_GLOBAL_ALPHA,
-        .global_alpha = sample->alpha,
-      };
-      /* *INDENT-ON* */
+      blend.flags |= VA_BLEND_GLOBAL_ALPHA;
+      blend.global_alpha = sample->alpha;
+    }
+    if (self->pipeline_caps.blend_flags & VA_BLEND_PREMULTIPLIED_ALPHA
+        && sample->premultiplied_alpha) {
+      blend.flags |= VA_BLEND_PREMULTIPLIED_ALPHA;
+    }
+    if (blend.flags != 0) {
       params.blend_state = &blend;
     }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/va/gstvafilter.h -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/va/gstvafilter.h Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/sys/wasapi2/gstwasapi2rbuf.cpp -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/sys/wasapi2/gstwasapi2rbuf.cpp Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/tests/check/elements/mpegtsdemux.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/tests/check/elements/mpegtsdemux.c Changed

@@ -19,6 +19,7 @@
  */
 
 #include <gst/gst.h>
+#include <gst/base/gstbasesrc.h>
 #include <gst/check/gstcheck.h>
 #include <gst/check/gstharness.h>
 
@@ -377,6 +378,138 @@
 
 GST_END_TEST;
 
+static void
+handoff_cb (GstElement * fakesink, GstBuffer * buffer, GstPad * pad,
+    GstClockTime * last_ts)
+{
+  GST_LOG ("Buffer %" GST_PTR_FORMAT, buffer);
+
+  /* Just check that the buffer PTS is within 0.1 seconds of the previous
+   * and no gap is introduced at rollover. PTS can go backward too, so
+   * allow for that by checking absolute TS */
+  GstClockTime pts = GST_BUFFER_PTS (buffer);
+
+  if (GST_CLOCK_TIME_IS_VALID (pts)) {
+    if (GST_CLOCK_TIME_IS_VALID (*last_ts)) {
+      GstClockTime pts_diff = ABS (GST_CLOCK_DIFF (*last_ts, pts));
+      GST_LOG ("PTS %" GST_TIMEP_FORMAT " prev %" GST_TIMEP_FORMAT " diff %"
+          GST_TIMEP_FORMAT, &pts, last_ts, &pts_diff);
+      fail_if (pts_diff > 100 * GST_MSECOND);
+    }
+    *last_ts = pts;
+  }
+}
+
+static void
+demux_pad_added (GstElement * demux, GstPad * srcpad, GstElement * pipeline)
+{
+  (void) demux;
+
+  GstCaps *caps = gst_pad_get_current_caps (srcpad);
+  fail_unless (caps != NULL);
+  gst_caps_unref (caps);
+
+  GstElement *sink = gst_bin_get_by_name (GST_BIN (pipeline), "fakesink");
+  fail_if (sink == NULL);
+  GstPad *target = gst_element_get_static_pad (sink, "sink");
+  fail_if (target == NULL);
+
+  GstPadLinkReturn ret = gst_pad_link (srcpad, target);
+  fail_unless (ret == GST_PAD_LINK_OK || ret == GST_PAD_LINK_WAS_LINKED);
+
+  gst_object_unref (target);
+  gst_object_unref (sink);
+}
+
+GST_START_TEST (test_tsdemux_ignore_pcr_rollover)
+{
+  GstClockTime last_ts = GST_CLOCK_TIME_NONE;
+
+  gchar *filepath =
+      g_build_filename (GST_TEST_FILES_PATH, "test_pcr_rollover.ts", NULL);
+  if (!g_file_test (filepath, G_FILE_TEST_EXISTS)) {
+    GST_INFO ("Skipping test, missing file: %s", filepath);
+    g_free (filepath);
+    return;
+  }
+  GST_LOG ("processing file '%s'", filepath);
+
+  char *data;
+  gsize datalen;
+
+  if (!g_file_get_contents (filepath, &data, &datalen, NULL)) {
+    ck_abort_msg ("Failed to read file contents from %s", filepath);
+    g_free (filepath);
+    return;
+  }
+
+  /* We'll send the entire file as a single zero-timestamp
+   * buffer */
+  GstBuffer *buf = gst_buffer_new_wrapped (data, datalen);
+  GST_BUFFER_PTS (buf) = 0;
+
+  GstElement *pipeline = gst_pipeline_new ("pipeline");
+  fail_unless (pipeline != NULL, "Failed to create pipeline!");
+
+  GstBus *bus = gst_element_get_bus (pipeline);
+
+  GstElement *src = gst_element_factory_make ("appsrc", "src");
+  fail_unless (src != NULL, "Failed to create 'appsrc' element!");
+  g_object_set (src, "format", GST_FORMAT_TIME, NULL);
+
+  GstElement *demux = gst_element_factory_make ("tsdemux", "tsdemux");
+  fail_unless (demux != NULL, "Failed to create 'tsdemux' element!");
+  g_object_set (demux, "ignore-pcr", TRUE, NULL);
+  g_signal_connect (demux, "pad-added", G_CALLBACK (demux_pad_added), pipeline);
+
+  GstElement *sink = gst_element_factory_make ("fakesink", "fakesink");
+  fail_unless (sink != NULL, "Failed to create 'fakesink' element!");
+
+  g_object_set (sink, "signal-handoffs", TRUE, NULL);
+  g_signal_connect (sink, "handoff", G_CALLBACK (handoff_cb), &last_ts);
+
+  gst_bin_add_many (GST_BIN (pipeline), src, demux, sink, NULL);
+
+  fail_unless (gst_element_link (src, demux));
+
+  GstStateChangeReturn state_ret =
+      gst_element_set_state (pipeline, GST_STATE_PAUSED);
+  fail_unless (state_ret != GST_STATE_CHANGE_FAILURE);
+
+  GstFlowReturn flowret = GST_FLOW_OK;
+  g_signal_emit_by_name (src, "push-buffer", buf, &flowret);
+  fail_unless (flowret == GST_FLOW_OK);
+  gst_buffer_unref (buf);
+
+  g_signal_emit_by_name (src, "end-of-stream", &flowret);
+  fail_unless (flowret == GST_FLOW_OK);
+
+  if (state_ret == GST_STATE_CHANGE_ASYNC) {
+    GST_LOG ("waiting for pipeline to reach PAUSED state");
+    state_ret = gst_element_get_state (pipeline, NULL, NULL, -1);
+    fail_unless_equals_int (state_ret, GST_STATE_CHANGE_SUCCESS);
+  }
+
+  state_ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
+  fail_unless (state_ret != GST_STATE_CHANGE_FAILURE);
+
+  GstMessage *msg = gst_bus_poll (bus, GST_MESSAGE_EOS | GST_MESSAGE_ERROR, -1);
+  fail_unless (msg != NULL, "Expected EOS message on bus!");
+  fail_unless (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_EOS);
+
+  gst_message_unref (msg);
+
+  fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_NULL),
+      GST_STATE_CHANGE_SUCCESS);
+
+  gst_object_unref (bus);
+  gst_object_unref (pipeline);
+
+  g_free (filepath);
+}
+
+GST_END_TEST;
+
 static Suite *
 mpegtsdemux_suite (void)
 {
@@ -394,6 +527,7 @@
   tc = tcase_create ("tsdemux");
   suite_add_tcase (s, tc);
   tcase_add_test (tc, test_tsdemux_simple);
+  tcase_add_test (tc, test_tsdemux_ignore_pcr_rollover);
 
   return s;
 }

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/tests/check/elements/netsim.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/tests/check/elements/netsim.c Changed

@@ -9,6 +9,15 @@
   GstHarnessThread *state, *push;
   GstSegment segment;
 
+  gst_check_add_log_filter ("GStreamer", G_LOG_LEVEL_WARNING,
+      g_regex_new ("Got data flow before (stream-start|segment) event",
+          (GRegexCompileFlags) 0, (GRegexMatchFlags) 0, NULL),
+      NULL, NULL, NULL);
+  gst_check_add_log_filter ("GStreamer", G_LOG_LEVEL_WARNING,
+      g_regex_new ("Sticky event misordering",
+          (GRegexCompileFlags) 0, (GRegexMatchFlags) 0, NULL),
+      NULL, NULL, NULL);
+
   gst_segment_init (&segment, GST_FORMAT_TIME);
   state = gst_harness_stress_statechange_start (h);
   push = gst_harness_stress_push_buffer_start (h, caps, &segment, buf);
@@ -33,6 +42,15 @@
   GstHarnessThread *state, *push;
   GstSegment segment;
 
+  gst_check_add_log_filter ("GStreamer", G_LOG_LEVEL_WARNING,
+      g_regex_new ("Got data flow before (stream-start|segment) event",
+          (GRegexCompileFlags) 0, (GRegexMatchFlags) 0, NULL),
+      NULL, NULL, NULL);
+  gst_check_add_log_filter ("GStreamer", G_LOG_LEVEL_WARNING,
+      g_regex_new ("Sticky event misordering",
+          (GRegexCompileFlags) 0, (GRegexMatchFlags) 0, NULL),
+      NULL, NULL, NULL);
+
   gst_harness_set_src_caps (h, gst_caps_ref (caps));
   buf = gst_harness_create_buffer (h, 100);
   gst_segment_init (&segment, GST_FORMAT_TIME);

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/tests/check/libs/av1parser.c -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/tests/check/libs/av1parser.c Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/tests/check/libs/gstlibscpp.cc -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/tests/check/libs/gstlibscpp.cc Changed

_service:download_files:gst-plugins-bad-1.28.3.tar.xz/tests/check/meson.build -> _service:download_files:gst-plugins-bad-1.28.5.tar.xz/tests/check/meson.build Changed

@@ -100,7 +100,7 @@
   'libs/nalutils.c', '../../gst-libs/gst/codecparsers/nalutils.c', false, nalutils_dep,
   'libs/mpegts.c', false, gstmpegts_dep,
   'libs/mpegvideoparser.c', false, gstcodecparsers_dep,
-  'libs/mse.c', false, gstmse_private_test_dep,
+  'libs/mse.c', not gstmse_private_test_dep.found(), gstmse_private_test_dep,
   'libs/planaraudioadapter.c', false, gstbadaudio_dep,
   'libs/play.c', not enable_gst_play_tests, gstplay_dep, libsoup_dep,
   'libs/vc1parser.c', false, gstcodecparsers_dep,
@@ -213,12 +213,17 @@
 
 test_deps = gst_dep, gstapp_dep, gstbase_dep, gstbadaudio_dep,
              gstbasecamerabin_dep, gstphotography_dep, gstwebrtc_dep,
-             gstmpegts_dep, gstmse_dep, gstplay_dep, gstplayer_dep,
+             gstmpegts_dep, gstplay_dep, gstplayer_dep,
              gstanalytics_dep, gstinsertbin_dep, gst_transcoder_dep,
              gstpbutils_dep, gstcontroller_dep, gstaudio_dep,
              gstvideo_dep, gstrtp_dep, gsturidownloader_dep,
              gstcheck_dep, gio_dep, gsttag_dep
 
+if get_option('mse').enabled()
+  test_defines += '-DGST_HAVE_MSE'
+  test_deps += gstmse_dep
+endif
+
 pluginsdirs =   
 
 if gst_dep.type_name() == 'pkgconfig'

_service:download_files:gst-plugins-bad-1.28.5.tar.xz/tests/files/test_pcr_rollover.ts Added

Changes of Revision 48