
Release notes for GStreamer Good Plugins 1.10.3

The GStreamer team is proud to announce the third bugfix release in the stable
1.10 release series of your favourite cross-platform multimedia framework!


This release only contains bugfixes and it is safe to update from 1.10.x. For a
full list of bugfixes see Bugzilla.


See /releases/1.10/ for the full release notes.


"Such ingratitude.  After all the times I've saved your life."


A collection of plugins you'd want to have right next to you on the
battlefield.  Shooting sharp and making no mistakes, these plugins have it
all: good looks, good code, and good licensing.  Documented and dressed up
in tests.  If you're looking for a role model to base your own plugin on,
here it is.


If you find a plot hole or a badly lip-synced line of code in them,
let us know - it is a matter of honour for us to ensure Blondie doesn't look
like he's been walking 100 miles through the desert without water.


This module contains a set of plugins that we consider to have good quality
  code, correct functionality, our preferred license (LGPL for the plugin
  code, LGPL or LGPL-compatible for the supporting library).
We believe distributors can safely ship these plugins.
People writing elements should base their code on these elements.


Other modules containing plugins are:


gst-plugins-base
contains a basic set of well-supported plugins
gst-plugins-ugly
contains a set of well-supported plugins, but might pose problems for
    distributors
gst-plugins-bad
contains a set of less supported plugins that haven't passed the
    rigorous quality testing we expect, or are still missing documentation
    and/or unit tests
gst-libav
contains a set of codecs plugins based on libav (formerly gst-ffmpeg)



  

Bugs fixed in this release
     
      * 775898 : scaletempo: crash in Totem when doing Slow - > Fast - > Slow playback
      * 754230 : qtdemux: support sparse time ranges in qtdemux without needing a seek for MSE
      * 765498 : qtdemux: Fix key_time in gst_qtdemux_adjust_seek()
      * 772646 : rtpjitterbuffer: fix lost-event using dts instead of pts
      * 773218 : rtpbin: pipeline gets an EOS when any rtpsources byes
      * 773891 : rtpjitterbuffer: fix timer-reuse bug
      * 773905 : rtpjitterbuffer: fix bug in reschedule_timer
      * 775071 : memory leak in usage of gst_pad_get_current_caps() API
      * 775450 : aacparse: invalid memory read in gst_aac_parse_sink_setcaps
      * 775451 : qtdemux: out of bounds read in qtdemux_tag_add_str_full
      * 775455 : qtdemux: memory leaks in qtdemux_inflate
      * 775472 : matroskademux: memory leak in matroska parser / gst_ebml_read_binary
      * 775479 : avidemux: memory leak in gst_avi_demux_riff_parse_vprp
      * 775543 : rtspsrc: redirect-on-play skips stream cleanup and TEARDOWN
      * 775794 : qtdemux: can not play xvid/mp2 quicktime format
      * 775888 : flxdec: memory leaks in gst_flxdec_chain
      * 776107 : qtdemux: Crashes when parsing edit lists due to missing size checks
      * 776720 : souphttpsrc: no request retry on early server termination
      * 777101 : rtspsrc: tcp interleaved data dropped if first sub-streams are skipped during SETUP
      * 777123 : wavparse: CRITICAL warning with injected flush stop event in pull mode
      * 777157 : qtdemux: seqh buffer not freed after calling qtdemux_parse_svq3_stsd_data()
      * 777174 : qtmux resets request pad counters on PAUSED- > READY
      * 777222 : souphttpsrc: redirect uri is never set
      * 777327 : v4l2allocator: memory type not correctly set in allocator probe
      * 777362 : qtmux: Error always printed after writing moov recovery file, regardless of success/failure
      * 777469 : qtdemux: out of bounds heap read in qtdemux_parse_samples
      * 777500 : avidemux: gst_avi_demux_parse_ncdt heap out of bounds read
      * 777532 : avidemux: invalid memory read in gst_avi_demux_parse_ncdt
      * 777832 : qtmux: Timecode track fixes for STSD entry

==== Download ====

You can find source releases of gst-plugins-good in the download
directory: https://gstreamer.freedesktop.org/src/gst-plugins-good/

The git repository and details how to clone it can be found at
http://cgit.freedesktop.org/gstreamer/gst-plugins-good/

==== Homepage ====

The project's website is https://gstreamer.freedesktop.org/

==== Support and Bugs ====

We use GNOME's bugzilla for bug reports and feature requests:
http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer

Please submit patches via bugzilla as well.

For help and support, please subscribe to and send questions to the
gstreamer-devel mailing list (see below for details).

There is also a #gstreamer IRC channel on the Freenode IRC network.

==== Developers ====

GStreamer is stored in Git, hosted at git.freedesktop.org, and can be cloned
from there (see link above).

Interested developers of the core library, plugins, and applications should
subscribe to the gstreamer-devel list.

        
Contributors to this release
    
      * Alejandro G. Castro
      * Andre McCurdy
      * Arnaud Vrac
      * Brendan Shanks
      * Edward Hervey
      * Enrique Ocaña González
      * Garima Gaur
      * Havard Graff
      * Heekyoung Seo
      * Jan Schmidt
      * Jean-Christophe Trotin
      * Matt Staples
      * Matthew Waters
      * Rahul Bedarkar
      * Sebastian Dröge
      * Seungha Yang
      * Vivia Nikolaidou
 