mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-06 09:29:42 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-good/gst/multifile/gstsplitmuxsink.c

4101 lines
140 KiB
C
Raw Normal View History

splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* GStreamer Muxer bin that splits output stream by size/time
splitmuxsink: add the ability to mux auxilliary video streams The primary video stream is used to select fragment cut points at keyframe boundaries. Auxilliary video streams may be broken up at any packet - so fragments may not start with a keyframe for those streams.
2019-05-25 12:08:05 +00:00
* Copyright (C) <2014-2019> Jan Schmidt <jan@centricular.com>
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:element-splitmuxsink
docs: Port all docstring to gtk-doc markdown
2018-10-22 09:39:24 +00:00
* @title: splitmuxsink
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
* @short_description: Muxer wrapper for splitting output stream by size or time
*
* This element wraps a muxer and a sink, and starts a new file when the mux
* contents are about to cross a threshold of maximum size of maximum time,
* splitting at video keyframe boundaries. Exactly one input video stream
splitmuxsink: allow non-video streams to serve as reference In the absence of a video stream, the first stream will be used as reference. https://bugzilla.gnome.org/show_bug.cgi?id=753617
2015-04-29 17:23:28 +00:00
* can be muxed, with as many accompanying audio and subtitle streams as
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
* desired.
*
* By default, it uses mp4mux and filesink, but they can be changed via
* the 'muxer' and 'sink' properties.
*
* The minimum file size is 1 GOP, however - so limits may be overrun if the
* distance between any 2 keyframes is larger than the limits.
*
splitmuxsink: allow non-video streams to serve as reference In the absence of a video stream, the first stream will be used as reference. https://bugzilla.gnome.org/show_bug.cgi?id=753617
2015-04-29 17:23:28 +00:00
* If a video stream is available, the splitting process is driven by the video
* stream contents, and the video stream must contain closed GOPs for the output
* file parts to be played individually correctly. In the absence of a video
* stream, the first available stream is used as reference for synchronization.
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
*
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
* In the async-finalize mode, when the threshold is crossed, the old muxer
* and sink is disconnected from the pipeline and left to finish the file
* asynchronously, and a new muxer and sink is created to continue with the
* next fragment. For that reason, instead of muxer and sink objects, the
* muxer-factory and sink-factory properties are used to construct the new
* objects, together with muxer-properties and sink-properties.
*
docs: Port all docstring to gtk-doc markdown
2018-10-22 09:39:24 +00:00
* ## Example pipelines
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
* |[
splitmuxsink: fix example pipeline properly x264enc might not have a max-key-int property, but it has a key-int-max property...
2015-02-10 16:00:07 +00:00
* gst-launch-1.0 -e v4l2src num-buffers=500 ! video/x-raw,width=320,height=240 ! videoconvert ! queue ! timeoverlay ! x264enc key-int-max=10 ! h264parse ! splitmuxsink location=video%02d.mov max-size-time=10000000000 max-size-bytes=1000000
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
* ]|
* Records a video stream captured from a v4l2 device and muxes it into
* ISO mp4 files, splitting as needed to limit size/duration to 10 seconds
* and 1MB maximum size.
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
*
* |[
* gst-launch-1.0 -e v4l2src num-buffers=500 ! video/x-raw,width=320,height=240 ! videoconvert ! queue ! timeoverlay ! x264enc key-int-max=10 ! h264parse ! splitmuxsink location=video%02d.mkv max-size-time=10000000000 muxer-factory=matroskamux muxer-properties="properties,streamable=true"
* ]|
* Records a video stream captured from a v4l2 device and muxer it into
* streamable Matroska files, splitting as needed to limit size/duration to 10
* seconds. Each file will finalize asynchronously.
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
*
* |[
* gst-launch-1.0 videotestsrc num-buffers=10 ! jpegenc ! .video splitmuxsink muxer=qtmux muxer-pad-map=x-pad-map,video=video_1 location=test%05d.mp4 -v
* ]|
* Records 10 frames to an mp4 file, using a muxer-pad-map to make explicit mappings between the splitmuxsink sink pad and the corresponding muxer pad
* it will deliver to.
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
#include <glib/gstdio.h>
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
#include <gst/video/video.h>
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
#include "gstsplitmuxsink.h"
GST_DEBUG_CATEGORY_STATIC (splitmux_debug);
#define GST_CAT_DEFAULT splitmux_debug
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
#define GST_SPLITMUX_STATE_LOCK(s) g_mutex_lock(&(s)->state_lock)
#define GST_SPLITMUX_STATE_UNLOCK(s) g_mutex_unlock(&(s)->state_lock)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
#define GST_SPLITMUX_LOCK(s) g_mutex_lock(&(s)->lock)
#define GST_SPLITMUX_UNLOCK(s) g_mutex_unlock(&(s)->lock)
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
#define GST_SPLITMUX_WAIT_INPUT(s) g_cond_wait (&(s)->input_cond, &(s)->lock)
#define GST_SPLITMUX_BROADCAST_INPUT(s) g_cond_broadcast (&(s)->input_cond)
#define GST_SPLITMUX_WAIT_OUTPUT(s) g_cond_wait (&(s)->output_cond, &(s)->lock)
#define GST_SPLITMUX_BROADCAST_OUTPUT(s) g_cond_broadcast (&(s)->output_cond)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
static void split_now (GstSplitMuxSink * splitmux);
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
static void split_after (GstSplitMuxSink * splitmux);
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
static void split_at_running_time (GstSplitMuxSink * splitmux,
GstClockTime split_time);
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
enum
{
PROP_0,
PROP_LOCATION,
splitmuxsink: provides a start-index property Allow to change the fragment-id start index.
2019-12-05 14:58:40 +00:00
PROP_START_INDEX,
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
PROP_MAX_SIZE_TIME,
PROP_MAX_SIZE_BYTES,
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
PROP_MAX_SIZE_TIMECODE,
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
PROP_SEND_KEYFRAME_REQUESTS,
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
PROP_MAX_FILES,
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
PROP_MUXER_OVERHEAD,
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
PROP_USE_ROBUST_MUXING,
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
PROP_ALIGNMENT_THRESHOLD,
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
PROP_MUXER,
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
PROP_SINK,
PROP_RESET_MUXER,
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
PROP_ASYNC_FINALIZE,
PROP_MUXER_FACTORY,
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
PROP_MUXER_PRESET,
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
PROP_MUXER_PROPERTIES,
PROP_SINK_FACTORY,
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
PROP_SINK_PRESET,
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
PROP_SINK_PROPERTIES,
PROP_MUXERPAD_MAP
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
};
#define DEFAULT_MAX_SIZE_TIME 0
#define DEFAULT_MAX_SIZE_BYTES 0
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
#define DEFAULT_MAX_FILES 0
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
#define DEFAULT_MUXER_OVERHEAD 0.02
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
#define DEFAULT_SEND_KEYFRAME_REQUESTS FALSE
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
#define DEFAULT_ALIGNMENT_THRESHOLD 0
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
#define DEFAULT_MUXER "mp4mux"
#define DEFAULT_SINK "filesink"
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
#define DEFAULT_USE_ROBUST_MUXING FALSE
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
#define DEFAULT_RESET_MUXER TRUE
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
#define DEFAULT_ASYNC_FINALIZE FALSE
splitmuxsink: provides a start-index property Allow to change the fragment-id start index.
2019-12-05 14:58:40 +00:00
#define DEFAULT_START_INDEX 0
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
typedef struct _AsyncEosHelper
{
MqStreamCtx *ctx;
GstPad *pad;
} AsyncEosHelper;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
enum
{
SIGNAL_FORMAT_LOCATION,
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
SIGNAL_FORMAT_LOCATION_FULL,
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
SIGNAL_SPLIT_NOW,
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
SIGNAL_SPLIT_AFTER,
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
SIGNAL_SPLIT_AT_RUNNING_TIME,
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
SIGNAL_MUXER_ADDED,
SIGNAL_SINK_ADDED,
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
SIGNAL_LAST
};
static guint signals[SIGNAL_LAST];
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static GstStaticPadTemplate video_sink_template =
GST_STATIC_PAD_TEMPLATE ("video",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS_ANY);
splitmuxsink: add the ability to mux auxilliary video streams The primary video stream is used to select fragment cut points at keyframe boundaries. Auxilliary video streams may be broken up at any packet - so fragments may not start with a keyframe for those streams.
2019-05-25 12:08:05 +00:00
static GstStaticPadTemplate video_aux_sink_template =
GST_STATIC_PAD_TEMPLATE ("video_aux_%u",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS_ANY);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static GstStaticPadTemplate audio_sink_template =
GST_STATIC_PAD_TEMPLATE ("audio_%u",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS_ANY);
static GstStaticPadTemplate subtitle_sink_template =
GST_STATIC_PAD_TEMPLATE ("subtitle_%u",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS_ANY);
splitmuxsink: Added caption_%u pad template For closed-caption-enabled muxers (e.g. qtmux)
2018-03-22 17:00:37 +00:00
static GstStaticPadTemplate caption_sink_template =
GST_STATIC_PAD_TEMPLATE ("caption_%u",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS_ANY);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static GQuark PAD_CONTEXT;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
static GQuark EOS_FROM_US;
static GQuark RUNNING_TIME;
/* EOS_FROM_US is only valid in async-finalize mode. We need to know whether
* to forward an incoming EOS message, but we cannot rely on the state of the
* splitmux anymore, so we set this qdata on the sink instead.
* The muxer and sink must be destroyed after both of these things have
* finished:
* 1) The EOS message has been sent when the fragment is ending
* 2) The muxer has been unlinked and relinked
* Therefore, EOS_FROM_US can have these two values:
* 0: EOS was not requested from us. Forward the message. The muxer and the
* sink will be destroyed together with the rest of the bin.
* 1: EOS was requested from us, but the other of the two tasks hasn't
* finished. Set EOS_FROM_US to 2 and do your stuff.
* 2: EOS was requested from us and the other of the two tasks has finished.
* Now we can destroy the muxer and the sink.
*/
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static void
_do_init (void)
{
PAD_CONTEXT = g_quark_from_static_string ("pad-context");
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
EOS_FROM_US = g_quark_from_static_string ("eos-from-us");
RUNNING_TIME = g_quark_from_static_string ("running-time");
multifile: allow per feature registration Split plugin into features including dynamic types which can be indiviually registered during a static build. More details here: https://gitlab.freedesktop.org/gstreamer/gst-build/-/merge_requests/199 https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/661 Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/876>
2021-02-16 11:04:26 +00:00
GST_DEBUG_CATEGORY_INIT (splitmux_debug, "splitmuxsink", 0,
"Split File Muxing Sink");
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
#define gst_splitmux_sink_parent_class parent_class
G_DEFINE_TYPE_EXTENDED (GstSplitMuxSink, gst_splitmux_sink, GST_TYPE_BIN, 0,
_do_init ());
multifile: allow per feature registration Split plugin into features including dynamic types which can be indiviually registered during a static build. More details here: https://gitlab.freedesktop.org/gstreamer/gst-build/-/merge_requests/199 https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/661 Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/876>
2021-02-16 11:04:26 +00:00
GST_ELEMENT_REGISTER_DEFINE (splitmuxsink, "splitmuxsink", GST_RANK_NONE,
GST_TYPE_SPLITMUX_SINK);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
static gboolean create_muxer (GstSplitMuxSink * splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static gboolean create_sink (GstSplitMuxSink * splitmux);
static void gst_splitmux_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_splitmux_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_splitmux_sink_dispose (GObject * object);
static void gst_splitmux_sink_finalize (GObject * object);
static GstPad *gst_splitmux_sink_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name, const GstCaps * caps);
static void gst_splitmux_sink_release_pad (GstElement * element, GstPad * pad);
static GstStateChangeReturn gst_splitmux_sink_change_state (GstElement *
element, GstStateChange transition);
static void bus_handler (GstBin * bin, GstMessage * msg);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
static void set_next_filename (GstSplitMuxSink * splitmux, MqStreamCtx * ctx);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
static GstFlowReturn start_next_fragment (GstSplitMuxSink * splitmux,
MqStreamCtx * ctx);
splitmuxsink: Fix reference counting loop The stream context was holding a reference to the internal queue and pads, with pad probes that were in turn holding references to the stream context. This lead to a leak if the request pads weren't explicitly released. https://bugzilla.gnome.org/show_bug.cgi?id=796893
2018-08-14 16:10:25 +00:00
static void mq_stream_ctx_free (MqStreamCtx * ctx);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
static void grow_blocked_queues (GstSplitMuxSink * splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
static void gst_splitmux_sink_ensure_max_files (GstSplitMuxSink * splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
static GstElement *create_element (GstSplitMuxSink * splitmux,
const gchar * factory, const gchar * name, gboolean locked);
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
static void do_async_done (GstSplitMuxSink * splitmux);
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
static GstClockTime calculate_next_max_timecode (GstSplitMuxSink * splitmux,
const GstVideoTimeCode * cur_tc, GstClockTime running_time,
GstVideoTimeCode ** next_tc);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static MqStreamBuf *
mq_stream_buf_new (void)
{
return g_slice_new0 (MqStreamBuf);
}
static void
mq_stream_buf_free (MqStreamBuf * data)
{
g_slice_free (MqStreamBuf, data);
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
static SplitMuxOutputCommand *
out_cmd_buf_new (void)
{
return g_slice_new0 (SplitMuxOutputCommand);
}
static void
out_cmd_buf_free (SplitMuxOutputCommand * data)
{
g_slice_free (SplitMuxOutputCommand, data);
}
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
static void
input_gop_free (InputGop * gop)
{
g_clear_pointer (&gop->start_tc, gst_video_time_code_free);
g_slice_free (InputGop, gop);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static void
gst_splitmux_sink_class_init (GstSplitMuxSinkClass * klass)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
GstElementClass *gstelement_class = (GstElementClass *) klass;
GstBinClass *gstbin_class = (GstBinClass *) klass;
gobject_class->set_property = gst_splitmux_sink_set_property;
gobject_class->get_property = gst_splitmux_sink_get_property;
gobject_class->dispose = gst_splitmux_sink_dispose;
gobject_class->finalize = gst_splitmux_sink_finalize;
gst_element_class_set_static_metadata (gstelement_class,
"Split Muxing Bin", "Generic/Bin/Muxer",
"Convenience bin that muxes incoming streams into multiple time/size limited files",
"Jan Schmidt <jan@centricular.com>");
good: use new gst_element_class_add_static_pad_template() https://bugzilla.gnome.org/show_bug.cgi?id=763076
2016-03-04 01:30:12 +00:00
gst_element_class_add_static_pad_template (gstelement_class,
&video_sink_template);
splitmuxsink: add the ability to mux auxilliary video streams The primary video stream is used to select fragment cut points at keyframe boundaries. Auxilliary video streams may be broken up at any packet - so fragments may not start with a keyframe for those streams.
2019-05-25 12:08:05 +00:00
gst_element_class_add_static_pad_template (gstelement_class,
&video_aux_sink_template);
good: use new gst_element_class_add_static_pad_template() https://bugzilla.gnome.org/show_bug.cgi?id=763076
2016-03-04 01:30:12 +00:00
gst_element_class_add_static_pad_template (gstelement_class,
&audio_sink_template);
gst_element_class_add_static_pad_template (gstelement_class,
&subtitle_sink_template);
splitmuxsink: Added caption_%u pad template For closed-caption-enabled muxers (e.g. qtmux)
2018-03-22 17:00:37 +00:00
gst_element_class_add_static_pad_template (gstelement_class,
&caption_sink_template);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gstelement_class->change_state =
GST_DEBUG_FUNCPTR (gst_splitmux_sink_change_state);
gstelement_class->request_new_pad =
GST_DEBUG_FUNCPTR (gst_splitmux_sink_request_new_pad);
gstelement_class->release_pad =
GST_DEBUG_FUNCPTR (gst_splitmux_sink_release_pad);
gstbin_class->handle_message = bus_handler;
g_object_class_install_property (gobject_class, PROP_LOCATION,
g_param_spec_string ("location", "File Output Pattern",
"Format string pattern for the location of the files to write (e.g. video%05d.mp4)",
NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_MUXER_OVERHEAD,
g_param_spec_double ("mux-overhead", "Muxing Overhead",
"Extra size overhead of muxing (0.02 = 2%)", 0.0, 1.0,
DEFAULT_MUXER_OVERHEAD,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_MAX_SIZE_TIME,
g_param_spec_uint64 ("max-size-time", "Max. size (ns)",
"Max. amount of time per file (in ns, 0=disable)", 0, G_MAXUINT64,
splitmuxsink: Mark some split decision related properties as MUTABLE_READY The change of various criteria for split decision while muxing is on progress wouldn't work well as expected.
2020-03-24 13:08:27 +00:00
DEFAULT_MAX_SIZE_TIME,
G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
G_PARAM_STATIC_STRINGS));
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_object_class_install_property (gobject_class, PROP_MAX_SIZE_BYTES,
g_param_spec_uint64 ("max-size-bytes", "Max. size bytes",
"Max. amount of data per file (in bytes, 0=disable)", 0, G_MAXUINT64,
splitmuxsink: Mark some split decision related properties as MUTABLE_READY The change of various criteria for split decision while muxing is on progress wouldn't work well as expected.
2020-03-24 13:08:27 +00:00
DEFAULT_MAX_SIZE_BYTES,
G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
G_PARAM_STATIC_STRINGS));
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
g_object_class_install_property (gobject_class, PROP_MAX_SIZE_TIMECODE,
g_param_spec_string ("max-size-timecode", "Maximum timecode difference",
"Maximum difference in timecode between first and last frame. "
"Separator is assumed to be \":\" everywhere (e.g. 01:00:00:00). "
splitmuxsink: Mark some split decision related properties as MUTABLE_READY The change of various criteria for split decision while muxing is on progress wouldn't work well as expected.
2020-03-24 13:08:27 +00:00
"Will only be effective if a timecode track is present.", NULL,
G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
G_PARAM_STATIC_STRINGS));
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
g_object_class_install_property (gobject_class, PROP_SEND_KEYFRAME_REQUESTS,
g_param_spec_boolean ("send-keyframe-requests",
"Request keyframes at max-size-time",
"Request a keyframe every max-size-time ns to try splitting at that point. "
"Needs max-size-bytes to be 0 in order to be effective.",
DEFAULT_SEND_KEYFRAME_REQUESTS,
splitmuxsink: Mark some split decision related properties as MUTABLE_READY The change of various criteria for split decision while muxing is on progress wouldn't work well as expected.
2020-03-24 13:08:27 +00:00
G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
G_PARAM_STATIC_STRINGS));
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
g_object_class_install_property (gobject_class, PROP_MAX_FILES,
g_param_spec_uint ("max-files", "Max files",
"Maximum number of files to keep on disk. Once the maximum is reached,"
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
"old files start to be deleted to make room for new ones.", 0,
G_MAXUINT, DEFAULT_MAX_FILES,
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
g_object_class_install_property (gobject_class, PROP_ALIGNMENT_THRESHOLD,
g_param_spec_uint64 ("alignment-threshold", "Alignment threshold (ns)",
"Allow non-reference streams to be that many ns before the reference"
splitmuxsink: Mark some split decision related properties as MUTABLE_READY The change of various criteria for split decision while muxing is on progress wouldn't work well as expected.
2020-03-24 13:08:27 +00:00
" stream", 0, G_MAXUINT64, DEFAULT_ALIGNMENT_THRESHOLD,
G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
G_PARAM_STATIC_STRINGS));
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_object_class_install_property (gobject_class, PROP_MUXER,
g_param_spec_object ("muxer", "Muxer",
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
"The muxer element to use (NULL = default mp4mux). "
"Valid only for async-finalize = FALSE",
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SINK,
g_param_spec_object ("sink", "Sink",
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
"The sink element (or element chain) to use (NULL = default filesink). "
"Valid only for async-finalize = FALSE",
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
g_object_class_install_property (gobject_class, PROP_USE_ROBUST_MUXING,
g_param_spec_boolean ("use-robust-muxing",
"Support robust-muxing mode of some muxers",
"Check if muxers support robust muxing via the reserved-max-duration and "
"reserved-duration-remaining properties and use them if so. "
"(Only present on qtmux and mp4mux for now). splitmuxsink may then also "
" create new fragments if the reserved header space is about to overflow. "
mp4 robust muxing: improve documentation and logging
2018-08-16 16:55:29 +00:00
"Note that for mp4mux and qtmux, reserved-moov-update-period must be set "
"manually by the app to a non-zero value for robust muxing to have an effect.",
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
DEFAULT_USE_ROBUST_MUXING,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
g_object_class_install_property (gobject_class, PROP_RESET_MUXER,
g_param_spec_boolean ("reset-muxer",
"Reset Muxer",
"Reset the muxer after each segment. Disabling this will not work for most muxers.",
DEFAULT_RESET_MUXER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
g_object_class_install_property (gobject_class, PROP_ASYNC_FINALIZE,
g_param_spec_boolean ("async-finalize",
"Finalize fragments asynchronously",
"Finalize each fragment asynchronously and start a new one",
DEFAULT_ASYNC_FINALIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_MUXER_FACTORY,
g_param_spec_string ("muxer-factory", "Muxer factory",
"The muxer element factory to use (default = mp4mux). "
"Valid only for async-finalize = TRUE",
"mp4mux", G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
/**
* GstSplitMuxSink:muxer-preset
*
* An optional #GstPreset name to use for the muxer. This only has an effect
* in `async-finalize=TRUE` mode.
*
* Since: 1.18
*/
g_object_class_install_property (gobject_class, PROP_MUXER_PRESET,
g_param_spec_string ("muxer-preset", "Muxer preset",
"The muxer preset to use. "
"Valid only for async-finalize = TRUE",
NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
g_object_class_install_property (gobject_class, PROP_MUXER_PROPERTIES,
g_param_spec_boxed ("muxer-properties", "Muxer properties",
"The muxer element properties to use. "
"Example: {properties,boolean-prop=true,string-prop=\"hi\"}. "
"Valid only for async-finalize = TRUE",
GST_TYPE_STRUCTURE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SINK_FACTORY,
g_param_spec_string ("sink-factory", "Sink factory",
"The sink element factory to use (default = filesink). "
"Valid only for async-finalize = TRUE",
"filesink", G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
/**
* GstSplitMuxSink:sink-preset
*
* An optional #GstPreset name to use for the sink. This only has an effect
* in `async-finalize=TRUE` mode.
*
* Since: 1.18
*/
g_object_class_install_property (gobject_class, PROP_SINK_PRESET,
g_param_spec_string ("sink-preset", "Sink preset",
"The sink preset to use. "
"Valid only for async-finalize = TRUE",
NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
g_object_class_install_property (gobject_class, PROP_SINK_PROPERTIES,
g_param_spec_boxed ("sink-properties", "Sink properties",
"The sink element properties to use. "
"Example: {properties,boolean-prop=true,string-prop=\"hi\"}. "
"Valid only for async-finalize = TRUE",
GST_TYPE_STRUCTURE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: provides a start-index property Allow to change the fragment-id start index.
2019-12-05 14:58:40 +00:00
g_object_class_install_property (gobject_class, PROP_START_INDEX,
g_param_spec_int ("start-index", "Start Index",
"Start value of fragment index.",
0, G_MAXINT, DEFAULT_START_INDEX,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
/**
* GstSplitMuxSink::muxer-pad-map
*
* An optional GstStructure that provides a map from splitmuxsink sinkpad
* names to muxer pad names they should feed. Splitmuxsink has some default
* mapping behaviour to link video to video pads and audio to audio pads
* that usually works fine. This property is useful if you need to ensure
* a particular mapping to muxed streams.
*
* The GstStructure contains string fields like so:
* splitmuxsink muxer-pad-map=x-pad-map,video=video_1
*
* Since: 1.18
*/
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MUXERPAD_MAP,
g_param_spec_boxed ("muxer-pad-map", "Muxer pad map",
"A GstStructure specifies the mapping from splitmuxsink sink pads to muxer pads",
GST_TYPE_STRUCTURE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
/**
* GstSplitMuxSink::format-location:
* @splitmux: the #GstSplitMuxSink
* @fragment_id: the sequence number of the file to be created
*
splitmuxsink: flesh out docs for format-location* signals Make explicit that the returned strings need to be g_free()-able. Fixes #753 Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/652>
2020-06-26 18:28:31 +00:00
* Returns: the location to be used for the next output file. This must be
* a newly-allocated string which will be freed with g_free() by the
* splitmuxsink element when it no longer needs it, so use g_strdup() or
* g_strdup_printf() or similar functions to allocate it.
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
*/
signals[SIGNAL_FORMAT_LOCATION] =
g_signal_new ("format-location", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_STRING, 1, G_TYPE_UINT);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
/**
* GstSplitMuxSink::format-location-full:
* @splitmux: the #GstSplitMuxSink
* @fragment_id: the sequence number of the file to be created
* @first_sample: A #GstSample containing the first buffer
* from the reference stream in the new file
*
splitmuxsink: flesh out docs for format-location* signals Make explicit that the returned strings need to be g_free()-able. Fixes #753 Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/652>
2020-06-26 18:28:31 +00:00
* Returns: the location to be used for the next output file. This must be
* a newly-allocated string which will be freed with g_free() by the
* splitmuxsink element when it no longer needs it, so use g_strdup() or
* g_strdup_printf() or similar functions to allocate it.
*
* Since: 1.12
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
*/
signals[SIGNAL_FORMAT_LOCATION_FULL] =
g_signal_new ("format-location-full", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_STRING, 2, G_TYPE_UINT,
GST_TYPE_SAMPLE);
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
/**
* GstSplitMuxSink::split-now:
* @splitmux: the #GstSplitMuxSink
*
* When called by the user, this action signal splits the video file (and begins a new one) immediately.
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
* The current GOP will be output to the new file.
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
*
* Since: 1.14
*/
signals[SIGNAL_SPLIT_NOW] =
g_signal_new ("split-now", G_TYPE_FROM_CLASS (klass),
splitmuxsink: Mark split-* signals as action signals. Doc fixes. Add the G_SIGNAL_ACTION flag to the split-* signals on splitmuxsink, and make some improvements to their docstrings
2019-07-25 16:13:31 +00:00
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstSplitMuxSinkClass, split_now), NULL, NULL, NULL,
G_TYPE_NONE, 0);
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
/**
* GstSplitMuxSink::split-after:
* @splitmux: the #GstSplitMuxSink
*
* When called by the user, this action signal splits the video file (and begins a new one) immediately.
splitmuxsink: Mark split-* signals as action signals. Doc fixes. Add the G_SIGNAL_ACTION flag to the split-* signals on splitmuxsink, and make some improvements to their docstrings
2019-07-25 16:13:31 +00:00
* Unlike the 'split-now' signal, with 'split-after', the current GOP will be output to the old file.
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
*
* Since: 1.16
*/
signals[SIGNAL_SPLIT_AFTER] =
g_signal_new ("split-after", G_TYPE_FROM_CLASS (klass),
splitmuxsink: Mark split-* signals as action signals. Doc fixes. Add the G_SIGNAL_ACTION flag to the split-* signals on splitmuxsink, and make some improvements to their docstrings
2019-07-25 16:13:31 +00:00
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstSplitMuxSinkClass, split_after), NULL, NULL, NULL,
G_TYPE_NONE, 0);
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
/**
splitmuxsink: Mark split-* signals as action signals. Doc fixes. Add the G_SIGNAL_ACTION flag to the split-* signals on splitmuxsink, and make some improvements to their docstrings
2019-07-25 16:13:31 +00:00
* GstSplitMuxSink::split-at-running-time:
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
* @splitmux: the #GstSplitMuxSink
*
* When called by the user, this action signal splits the video file (and
* begins a new one) as soon as the given running time is reached. If this
* action signal is called multiple times, running times are queued up and
* processed in the order they were given.
*
* Note that this is prone to race conditions, where said running time is
* reached and surpassed before we had a chance to split. The file will
* still split immediately, but in order to make sure that the split doesn't
* happen too late, it is recommended to call this action signal from
* something that will prevent further buffers from flowing into
* splitmuxsink before the split is completed, such as a pad probe before
* splitmuxsink.
*
*
* Since: 1.16
*/
signals[SIGNAL_SPLIT_AT_RUNNING_TIME] =
g_signal_new ("split-at-running-time", G_TYPE_FROM_CLASS (klass),
splitmuxsink: Mark split-* signals as action signals. Doc fixes. Add the G_SIGNAL_ACTION flag to the split-* signals on splitmuxsink, and make some improvements to their docstrings
2019-07-25 16:13:31 +00:00
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstSplitMuxSinkClass, split_at_running_time), NULL, NULL,
NULL, G_TYPE_NONE, 1, G_TYPE_UINT64);
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
/**
* GstSplitMuxSink::muxer-added:
* @splitmux: the #GstSplitMuxSink
* @muxer: the newly added muxer element
*
* Since: 1.14
*/
signals[SIGNAL_MUXER_ADDED] =
g_signal_new ("muxer-added", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
/**
* GstSplitMuxSink::sink-added:
* @splitmux: the #GstSplitMuxSink
* @sink: the newly added sink element
*
* Since: 1.14
*/
signals[SIGNAL_SINK_ADDED] =
g_signal_new ("sink-added", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
klass->split_now = split_now;
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
klass->split_after = split_after;
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
klass->split_at_running_time = split_at_running_time;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
static void
gst_splitmux_sink_init (GstSplitMuxSink * splitmux)
{
g_mutex_init (&splitmux->lock);
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
g_mutex_init (&splitmux->state_lock);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
g_cond_init (&splitmux->input_cond);
g_cond_init (&splitmux->output_cond);
g_queue_init (&splitmux->out_cmd_q);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux->mux_overhead = DEFAULT_MUXER_OVERHEAD;
splitmux->threshold_time = DEFAULT_MAX_SIZE_TIME;
splitmux->threshold_bytes = DEFAULT_MAX_SIZE_BYTES;
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
splitmux->max_files = DEFAULT_MAX_FILES;
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
splitmux->send_keyframe_requests = DEFAULT_SEND_KEYFRAME_REQUESTS;
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
splitmux->alignment_threshold = DEFAULT_ALIGNMENT_THRESHOLD;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
splitmux->use_robust_muxing = DEFAULT_USE_ROBUST_MUXING;
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
splitmux->reset_muxer = DEFAULT_RESET_MUXER;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
splitmux->threshold_timecode_str = NULL;
splitmuxsink: flag as sink from the start
2015-02-13 20:40:48 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
splitmux->async_finalize = DEFAULT_ASYNC_FINALIZE;
splitmux->muxer_factory = g_strdup (DEFAULT_MUXER);
splitmux->muxer_properties = NULL;
splitmux->sink_factory = g_strdup (DEFAULT_SINK);
splitmux->sink_properties = NULL;
splitmuxsink: flag as sink from the start
2015-02-13 20:40:48 +00:00
GST_OBJECT_FLAG_SET (splitmux, GST_ELEMENT_FLAG_SINK);
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
splitmux->split_requested = FALSE;
splitmux->do_split_next_gop = FALSE;
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
splitmux->times_to_split = gst_queue_array_new_for_struct (8, 8);
splitmuxsink: Don't send too many force key unit event splitmuxsink should requst keyframe depending on configured threshold and previously requested time in order to avoid too many keyframe request.
2020-04-03 04:45:56 +00:00
splitmux->next_fku_time = GST_CLOCK_TIME_NONE;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
g_queue_init (&splitmux->pending_input_gops);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
static void
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
gst_splitmux_reset_elements (GstSplitMuxSink * splitmux)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
{
splitmuxsink: Set child elements to NULL when removing. Make sure that elements are in the NULL state when removing. Fixes critical warnings when errors occur early on in starting up.
2016-10-25 03:51:52 +00:00
if (splitmux->muxer) {
gst_element_set_locked_state (splitmux->muxer, TRUE);
gst_element_set_state (splitmux->muxer, GST_STATE_NULL);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gst_bin_remove (GST_BIN (splitmux), splitmux->muxer);
splitmuxsink: Set child elements to NULL when removing. Make sure that elements are in the NULL state when removing. Fixes critical warnings when errors occur early on in starting up.
2016-10-25 03:51:52 +00:00
}
if (splitmux->active_sink) {
gst_element_set_locked_state (splitmux->active_sink, TRUE);
gst_element_set_state (splitmux->active_sink, GST_STATE_NULL);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gst_bin_remove (GST_BIN (splitmux), splitmux->active_sink);
splitmuxsink: Set child elements to NULL when removing. Make sure that elements are in the NULL state when removing. Fixes critical warnings when errors occur early on in starting up.
2016-10-25 03:51:52 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->sink = splitmux->active_sink = splitmux->muxer = NULL;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
static void
gst_splitmux_sink_dispose (GObject * object)
{
GstSplitMuxSink *splitmux = GST_SPLITMUX_SINK (object);
/* Calling parent dispose invalidates all child pointers */
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->sink = splitmux->active_sink = splitmux->muxer = NULL;
splitmuxsink: Fix GObject warnings on shutdown. Commit 83e718 added a pad template to splitmux request pads, which means that GstElement now releases the pads on dispose, but after having removed all elements in the bin and unlinked them. Make sure we can handle cleanup in that case without throwing assertions. https://bugzilla.gnome.org/show_bug.cgi?id=773784
2016-11-02 00:00:13 +00:00
G_OBJECT_CLASS (parent_class)->dispose (object);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
static void
gst_splitmux_sink_finalize (GObject * object)
{
GstSplitMuxSink *splitmux = GST_SPLITMUX_SINK (object);
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
g_cond_clear (&splitmux->input_cond);
g_cond_clear (&splitmux->output_cond);
splitmuxsink: fix mutex leak
2015-04-09 11:58:26 +00:00
g_mutex_clear (&splitmux->lock);
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
g_mutex_clear (&splitmux->state_lock);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
g_queue_foreach (&splitmux->out_cmd_q, (GFunc) out_cmd_buf_free, NULL);
g_queue_clear (&splitmux->out_cmd_q);
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
g_queue_foreach (&splitmux->pending_input_gops, (GFunc) input_gop_free, NULL);
g_queue_clear (&splitmux->pending_input_gops);
g_clear_pointer (&splitmux->fragment_start_tc, gst_video_time_code_free);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
if (splitmux->muxerpad_map)
gst_structure_free (splitmux->muxerpad_map);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
if (splitmux->provided_sink)
gst_object_unref (splitmux->provided_sink);
splitmux: Add unit test for file splitting Add a unit test for file splitting, and fix the leaks in the splitmuxsink it found
2015-02-06 14:41:49 +00:00
if (splitmux->provided_muxer)
gst_object_unref (splitmux->provided_muxer);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->muxer_factory)
g_free (splitmux->muxer_factory);
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
if (splitmux->muxer_preset)
g_free (splitmux->muxer_preset);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->muxer_properties)
gst_structure_free (splitmux->muxer_properties);
if (splitmux->sink_factory)
g_free (splitmux->sink_factory);
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
if (splitmux->sink_preset)
g_free (splitmux->sink_preset);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->sink_properties)
gst_structure_free (splitmux->sink_properties);
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
if (splitmux->threshold_timecode_str)
g_free (splitmux->threshold_timecode_str);
splitmuxsink: Take account queued time and max-size-timecode for split decision Not only the requested keyframe time, the queued size should be a criterion for the split decision of timecode based mode (same as max-size-time based split case).
2020-03-24 04:45:00 +00:00
if (splitmux->tc_interval)
gst_video_time_code_interval_free (splitmux->tc_interval);
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
if (splitmux->times_to_split)
gst_queue_array_free (splitmux->times_to_split);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_free (splitmux->location);
splitmuxsink: Fix reference counting loop The stream context was holding a reference to the internal queue and pads, with pad probes that were in turn holding references to the stream context. This lead to a leak if the request pads weren't explicitly released. https://bugzilla.gnome.org/show_bug.cgi?id=796893
2018-08-14 16:10:25 +00:00
/* Make sure to free any un-released contexts. There should not be any,
* because the dispose will have freed all request pads though */
g_list_foreach (splitmux->contexts, (GFunc) mq_stream_ctx_free, NULL);
splitmux: Add unit test for file splitting Add a unit test for file splitting, and fix the leaks in the splitmuxsink it found
2015-02-06 14:41:49 +00:00
g_list_free (splitmux->contexts);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
G_OBJECT_CLASS (parent_class)->finalize (object);
}
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
/*
* Set any time threshold to the muxer, if it has
* reserved-max-duration and reserved-duration-remaining
* properties. Called when creating/claiming the muxer
* in create_elements() */
static void
update_muxer_properties (GstSplitMuxSink * sink)
{
GObjectClass *klass;
GstClockTime threshold_time;
sink->muxer_has_reserved_props = FALSE;
if (sink->muxer == NULL)
return;
klass = G_OBJECT_GET_CLASS (sink->muxer);
if (g_object_class_find_property (klass, "reserved-max-duration") == NULL)
return;
if (g_object_class_find_property (klass,
"reserved-duration-remaining") == NULL)
return;
sink->muxer_has_reserved_props = TRUE;
GST_LOG_OBJECT (sink, "Setting muxer reserved time to %" GST_TIME_FORMAT,
GST_TIME_ARGS (sink->threshold_time));
GST_OBJECT_LOCK (sink);
threshold_time = sink->threshold_time;
GST_OBJECT_UNLOCK (sink);
if (threshold_time > 0) {
/* Tell the muxer how much space to reserve */
GstClockTime muxer_threshold = threshold_time;
g_object_set (sink->muxer, "reserved-max-duration", muxer_threshold, NULL);
}
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static void
gst_splitmux_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstSplitMuxSink *splitmux = GST_SPLITMUX_SINK (object);
switch (prop_id) {
case PROP_LOCATION:{
GST_OBJECT_LOCK (splitmux);
g_free (splitmux->location);
splitmux->location = g_value_dup_string (value);
GST_OBJECT_UNLOCK (splitmux);
break;
}
splitmuxsink: provides a start-index property Allow to change the fragment-id start index.
2019-12-05 14:58:40 +00:00
case PROP_START_INDEX:
GST_OBJECT_LOCK (splitmux);
splitmux->start_index = g_value_get_int (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
case PROP_MAX_SIZE_BYTES:
GST_OBJECT_LOCK (splitmux);
splitmux->threshold_bytes = g_value_get_uint64 (value);
GST_OBJECT_UNLOCK (splitmux);
break;
case PROP_MAX_SIZE_TIME:
GST_OBJECT_LOCK (splitmux);
splitmux->threshold_time = g_value_get_uint64 (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
case PROP_MAX_SIZE_TIMECODE:
GST_OBJECT_LOCK (splitmux);
splitmuxsink: Take account queued time and max-size-timecode for split decision Not only the requested keyframe time, the queued size should be a criterion for the split decision of timecode based mode (same as max-size-time based split case).
2020-03-24 04:45:00 +00:00
g_free (splitmux->threshold_timecode_str);
/* will be calculated later */
g_clear_pointer (&splitmux->tc_interval,
gst_video_time_code_interval_free);
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
splitmux->threshold_timecode_str = g_value_dup_string (value);
splitmuxsink: Take account queued time and max-size-timecode for split decision Not only the requested keyframe time, the queued size should be a criterion for the split decision of timecode based mode (same as max-size-time based split case).
2020-03-24 04:45:00 +00:00
if (splitmux->threshold_timecode_str) {
splitmux->tc_interval =
gst_video_time_code_interval_new_from_string
(splitmux->threshold_timecode_str);
if (!splitmux->tc_interval) {
g_warning ("Wrong timecode string %s",
splitmux->threshold_timecode_str);
g_free (splitmux->threshold_timecode_str);
splitmux->threshold_timecode_str = NULL;
}
}
splitmuxsink: Warn when calculating the next fragment time in timecode mode fails But only if timecode mode is enabled as it will fail all the time otherwise. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1557>
2022-01-24 08:45:33 +00:00
splitmux->next_fragment_start_tc_time =
calculate_next_max_timecode (splitmux, splitmux->fragment_start_tc,
splitmux->fragment_start_time, NULL);
if (splitmux->tc_interval && splitmux->fragment_start_tc
&& !GST_CLOCK_TIME_IS_VALID (splitmux->next_fragment_start_tc_time)) {
GST_WARNING_OBJECT (splitmux,
"Couldn't calculate next fragment start time for timecode mode");
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
}
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
case PROP_SEND_KEYFRAME_REQUESTS:
GST_OBJECT_LOCK (splitmux);
splitmux->send_keyframe_requests = g_value_get_boolean (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
case PROP_MAX_FILES:
GST_OBJECT_LOCK (splitmux);
splitmux->max_files = g_value_get_uint (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
case PROP_MUXER_OVERHEAD:
GST_OBJECT_LOCK (splitmux);
splitmux->mux_overhead = g_value_get_double (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
case PROP_USE_ROBUST_MUXING:
GST_OBJECT_LOCK (splitmux);
splitmux->use_robust_muxing = g_value_get_boolean (value);
GST_OBJECT_UNLOCK (splitmux);
if (splitmux->use_robust_muxing)
update_muxer_properties (splitmux);
break;
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
case PROP_ALIGNMENT_THRESHOLD:
GST_OBJECT_LOCK (splitmux);
splitmux->alignment_threshold = g_value_get_uint64 (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
case PROP_SINK:
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GST_OBJECT_LOCK (splitmux);
splitmuxsink: Fix assertion failure on set_property() GValue might have null object. (gst-inspect-1.0:10304): GStreamer-CRITICAL ... gst_object_ref_sink: assertion 'object != NULL' failed
2020-01-06 16:20:24 +00:00
gst_clear_object (&splitmux->provided_sink);
splitmuxsink: Take ownership of floating refs sink the floating ref when handed a muxer or sink to use so we clearly take ownership.
2016-10-26 00:59:32 +00:00
splitmux->provided_sink = g_value_get_object (value);
splitmuxsink: Fix assertion failure on set_property() GValue might have null object. (gst-inspect-1.0:10304): GStreamer-CRITICAL ... gst_object_ref_sink: assertion 'object != NULL' failed
2020-01-06 16:20:24 +00:00
if (splitmux->provided_sink)
gst_object_ref_sink (splitmux->provided_sink);
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GST_OBJECT_UNLOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
case PROP_MUXER:
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GST_OBJECT_LOCK (splitmux);
splitmuxsink: Fix assertion failure on set_property() GValue might have null object. (gst-inspect-1.0:10304): GStreamer-CRITICAL ... gst_object_ref_sink: assertion 'object != NULL' failed
2020-01-06 16:20:24 +00:00
gst_clear_object (&splitmux->provided_muxer);
splitmuxsink: Take ownership of floating refs sink the floating ref when handed a muxer or sink to use so we clearly take ownership.
2016-10-26 00:59:32 +00:00
splitmux->provided_muxer = g_value_get_object (value);
splitmuxsink: Fix assertion failure on set_property() GValue might have null object. (gst-inspect-1.0:10304): GStreamer-CRITICAL ... gst_object_ref_sink: assertion 'object != NULL' failed
2020-01-06 16:20:24 +00:00
if (splitmux->provided_muxer)
gst_object_ref_sink (splitmux->provided_muxer);
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GST_OBJECT_UNLOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
case PROP_RESET_MUXER:
GST_OBJECT_LOCK (splitmux);
splitmux->reset_muxer = g_value_get_boolean (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
case PROP_ASYNC_FINALIZE:
GST_OBJECT_LOCK (splitmux);
splitmux->async_finalize = g_value_get_boolean (value);
GST_OBJECT_UNLOCK (splitmux);
break;
case PROP_MUXER_FACTORY:
GST_OBJECT_LOCK (splitmux);
if (splitmux->muxer_factory)
g_free (splitmux->muxer_factory);
splitmux->muxer_factory = g_value_dup_string (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
case PROP_MUXER_PRESET:
GST_OBJECT_LOCK (splitmux);
if (splitmux->muxer_preset)
g_free (splitmux->muxer_preset);
splitmux->muxer_preset = g_value_dup_string (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
case PROP_MUXER_PROPERTIES:
GST_OBJECT_LOCK (splitmux);
if (splitmux->muxer_properties)
gst_structure_free (splitmux->muxer_properties);
if (gst_value_get_structure (value))
splitmux->muxer_properties =
gst_structure_copy (gst_value_get_structure (value));
else
splitmux->muxer_properties = NULL;
GST_OBJECT_UNLOCK (splitmux);
break;
case PROP_SINK_FACTORY:
GST_OBJECT_LOCK (splitmux);
if (splitmux->sink_factory)
g_free (splitmux->sink_factory);
splitmux->sink_factory = g_value_dup_string (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
case PROP_SINK_PRESET:
GST_OBJECT_LOCK (splitmux);
if (splitmux->sink_preset)
g_free (splitmux->sink_preset);
splitmux->sink_preset = g_value_dup_string (value);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
case PROP_SINK_PROPERTIES:
GST_OBJECT_LOCK (splitmux);
if (splitmux->sink_properties)
gst_structure_free (splitmux->sink_properties);
if (gst_value_get_structure (value))
splitmux->sink_properties =
gst_structure_copy (gst_value_get_structure (value));
else
splitmux->sink_properties = NULL;
GST_OBJECT_UNLOCK (splitmux);
break;
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
case PROP_MUXERPAD_MAP:
{
const GstStructure *s = gst_value_get_structure (value);
GST_SPLITMUX_LOCK (splitmux);
if (splitmux->muxerpad_map) {
gst_structure_free (splitmux->muxerpad_map);
}
if (s)
splitmux->muxerpad_map = gst_structure_copy (s);
else
splitmux->muxerpad_map = NULL;
GST_SPLITMUX_UNLOCK (splitmux);
break;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_splitmux_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstSplitMuxSink *splitmux = GST_SPLITMUX_SINK (object);
switch (prop_id) {
case PROP_LOCATION:
GST_OBJECT_LOCK (splitmux);
g_value_set_string (value, splitmux->location);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: provides a start-index property Allow to change the fragment-id start index.
2019-12-05 14:58:40 +00:00
case PROP_START_INDEX:
GST_OBJECT_LOCK (splitmux);
g_value_set_int (value, splitmux->start_index);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
case PROP_MAX_SIZE_BYTES:
GST_OBJECT_LOCK (splitmux);
g_value_set_uint64 (value, splitmux->threshold_bytes);
GST_OBJECT_UNLOCK (splitmux);
break;
case PROP_MAX_SIZE_TIME:
GST_OBJECT_LOCK (splitmux);
g_value_set_uint64 (value, splitmux->threshold_time);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
case PROP_MAX_SIZE_TIMECODE:
GST_OBJECT_LOCK (splitmux);
g_value_set_string (value, splitmux->threshold_timecode_str);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
case PROP_SEND_KEYFRAME_REQUESTS:
GST_OBJECT_LOCK (splitmux);
g_value_set_boolean (value, splitmux->send_keyframe_requests);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
case PROP_MAX_FILES:
GST_OBJECT_LOCK (splitmux);
g_value_set_uint (value, splitmux->max_files);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
case PROP_MUXER_OVERHEAD:
GST_OBJECT_LOCK (splitmux);
g_value_set_double (value, splitmux->mux_overhead);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
case PROP_USE_ROBUST_MUXING:
GST_OBJECT_LOCK (splitmux);
g_value_set_boolean (value, splitmux->use_robust_muxing);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
case PROP_ALIGNMENT_THRESHOLD:
GST_OBJECT_LOCK (splitmux);
g_value_set_uint64 (value, splitmux->alignment_threshold);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
case PROP_SINK:
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GST_OBJECT_LOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_value_set_object (value, splitmux->provided_sink);
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GST_OBJECT_UNLOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
case PROP_MUXER:
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GST_OBJECT_LOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_value_set_object (value, splitmux->provided_muxer);
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GST_OBJECT_UNLOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
case PROP_RESET_MUXER:
GST_OBJECT_LOCK (splitmux);
g_value_set_boolean (value, splitmux->reset_muxer);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
case PROP_ASYNC_FINALIZE:
GST_OBJECT_LOCK (splitmux);
g_value_set_boolean (value, splitmux->async_finalize);
GST_OBJECT_UNLOCK (splitmux);
break;
case PROP_MUXER_FACTORY:
GST_OBJECT_LOCK (splitmux);
g_value_set_string (value, splitmux->muxer_factory);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
case PROP_MUXER_PRESET:
GST_OBJECT_LOCK (splitmux);
g_value_set_string (value, splitmux->muxer_preset);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
case PROP_MUXER_PROPERTIES:
GST_OBJECT_LOCK (splitmux);
gst_value_set_structure (value, splitmux->muxer_properties);
GST_OBJECT_UNLOCK (splitmux);
break;
case PROP_SINK_FACTORY:
GST_OBJECT_LOCK (splitmux);
g_value_set_string (value, splitmux->sink_factory);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
case PROP_SINK_PRESET:
GST_OBJECT_LOCK (splitmux);
g_value_set_string (value, splitmux->sink_preset);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
case PROP_SINK_PROPERTIES:
GST_OBJECT_LOCK (splitmux);
gst_value_set_structure (value, splitmux->sink_properties);
GST_OBJECT_UNLOCK (splitmux);
break;
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
case PROP_MUXERPAD_MAP:
GST_SPLITMUX_LOCK (splitmux);
gst_value_set_structure (value, splitmux->muxerpad_map);
GST_SPLITMUX_UNLOCK (splitmux);
break;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
/* Convenience function */
static inline GstClockTimeDiff
my_segment_to_running_time (GstSegment * segment, GstClockTime val)
{
GstClockTimeDiff res = GST_CLOCK_STIME_NONE;
if (GST_CLOCK_TIME_IS_VALID (val)) {
gboolean sign =
gst_segment_to_running_time_full (segment, GST_FORMAT_TIME, val, &val);
if (sign > 0)
res = val;
else if (sign < 0)
res = -val;
}
return res;
}
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
static void
mq_stream_ctx_reset (MqStreamCtx * ctx)
{
gst_segment_init (&ctx->in_segment, GST_FORMAT_UNDEFINED);
gst_segment_init (&ctx->out_segment, GST_FORMAT_UNDEFINED);
ctx->in_running_time = ctx->out_running_time = GST_CLOCK_STIME_NONE;
g_queue_foreach (&ctx->queued_bufs, (GFunc) mq_stream_buf_free, NULL);
g_queue_clear (&ctx->queued_bufs);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static MqStreamCtx *
mq_stream_ctx_new (GstSplitMuxSink * splitmux)
{
MqStreamCtx *ctx;
ctx = g_new0 (MqStreamCtx, 1);
ctx->splitmux = splitmux;
g_queue_init (&ctx->queued_bufs);
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
mq_stream_ctx_reset (ctx);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
return ctx;
}
static void
mq_stream_ctx_free (MqStreamCtx * ctx)
{
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (ctx->q) {
splitmuxsink: Fix reference counting loop The stream context was holding a reference to the internal queue and pads, with pad probes that were in turn holding references to the stream context. This lead to a leak if the request pads weren't explicitly released. https://bugzilla.gnome.org/show_bug.cgi?id=796893
2018-08-14 16:10:25 +00:00
GstObject *parent = gst_object_get_parent (GST_OBJECT (ctx->q));
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
g_signal_handler_disconnect (ctx->q, ctx->q_overrun_id);
splitmuxsink: Fix reference counting loop The stream context was holding a reference to the internal queue and pads, with pad probes that were in turn holding references to the stream context. This lead to a leak if the request pads weren't explicitly released. https://bugzilla.gnome.org/show_bug.cgi?id=796893
2018-08-14 16:10:25 +00:00
if (parent == GST_OBJECT_CAST (ctx->splitmux)) {
gst_element_set_locked_state (ctx->q, TRUE);
gst_element_set_state (ctx->q, GST_STATE_NULL);
gst_bin_remove (GST_BIN (ctx->splitmux), ctx->q);
gst_object_unref (parent);
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
gst_object_unref (ctx->q);
}
gst_object_unref (ctx->sinkpad);
gst_object_unref (ctx->srcpad);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_queue_foreach (&ctx->queued_bufs, (GFunc) mq_stream_buf_free, NULL);
g_queue_clear (&ctx->queued_bufs);
g_free (ctx);
}
splitmuxsink: post messages when fragments are being opened and closed This can be useful for applications that need to track the created fragments (to log them in a recording database, for example) https://bugzilla.gnome.org/show_bug.cgi?id=750108
2015-04-17 12:25:43 +00:00
static void
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
send_fragment_opened_closed_msg (GstSplitMuxSink * splitmux, gboolean opened,
GstElement * sink)
splitmuxsink: post messages when fragments are being opened and closed This can be useful for applications that need to track the created fragments (to log them in a recording database, for example) https://bugzilla.gnome.org/show_bug.cgi?id=750108
2015-04-17 12:25:43 +00:00
{
gchar *location = NULL;
GstMessage *msg;
const gchar *msg_name = opened ?
"splitmuxsink-fragment-opened" : "splitmuxsink-fragment-closed";
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GstClockTime running_time = splitmux->reference_ctx->out_running_time;
if (!opened) {
GstClockTime *rtime = g_object_get_qdata (G_OBJECT (sink), RUNNING_TIME);
if (rtime)
running_time = *rtime;
}
splitmuxsink: post messages when fragments are being opened and closed This can be useful for applications that need to track the created fragments (to log them in a recording database, for example) https://bugzilla.gnome.org/show_bug.cgi?id=750108
2015-04-17 12:25:43 +00:00
splitmuxsink: Check the correct sink class for the existence of the "location" property
2020-01-27 13:52:42 +00:00
if (g_object_class_find_property (G_OBJECT_GET_CLASS (sink),
splitmuxsink: add fakesink support fakesink does not support "location" property and was generating a warning.
2019-11-07 11:28:58 +00:00
"location") != NULL)
g_object_get (sink, "location", &location, NULL);
splitmuxsink: Add debug for fragment opened/closed msgs When posting fragment-opened and fragment-closed messages, put a debug statement in the logs Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-09-14 14:27:24 +00:00
GST_DEBUG_OBJECT (splitmux,
"Sending %s message. Running time %" GST_TIME_FORMAT " location %s",
msg_name, GST_TIME_ARGS (running_time), GST_STR_NULL (location));
splitmuxsink: post messages when fragments are being opened and closed This can be useful for applications that need to track the created fragments (to log them in a recording database, for example) https://bugzilla.gnome.org/show_bug.cgi?id=750108
2015-04-17 12:25:43 +00:00
splitmuxsink: Don't send fragment-opened-closed message if the reference ctx is NULL It can happen during teardown that the reference context becomes NULL. In that case, trying to send the fragment-opened-closed message would lead to a crash.
2018-04-11 14:54:38 +00:00
/* If it's in the middle of a teardown, the reference_ctc might have become
* NULL */
if (splitmux->reference_ctx) {
msg = gst_message_new_element (GST_OBJECT (splitmux),
gst_structure_new (msg_name,
"location", G_TYPE_STRING, location,
splitmuxsink: Include actual sink element in the fragment-opened/closed messages If not configuring the sinks via the "location" property this can be useful to know for which sink the fragment was actually opened/closed, especially if finalization of the fragments is happening asynchronously.
2020-01-27 14:00:30 +00:00
"running-time", GST_TYPE_CLOCK_TIME, running_time,
"sink", GST_TYPE_ELEMENT, sink, NULL));
splitmuxsink: Don't send fragment-opened-closed message if the reference ctx is NULL It can happen during teardown that the reference context becomes NULL. In that case, trying to send the fragment-opened-closed message would lead to a crash.
2018-04-11 14:54:38 +00:00
gst_element_post_message (GST_ELEMENT_CAST (splitmux), msg);
}
splitmuxsink: post messages when fragments are being opened and closed This can be useful for applications that need to track the created fragments (to log them in a recording database, for example) https://bugzilla.gnome.org/show_bug.cgi?id=750108
2015-04-17 12:25:43 +00:00
g_free (location);
}
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
static void
send_eos_async (GstSplitMuxSink * splitmux, AsyncEosHelper * helper)
{
GstEvent *eos;
GstPad *pad;
MqStreamCtx *ctx;
eos = gst_event_new_eos ();
pad = helper->pad;
ctx = helper->ctx;
GST_SPLITMUX_LOCK (splitmux);
if (!pad)
pad = gst_pad_get_peer (ctx->srcpad);
GST_SPLITMUX_UNLOCK (splitmux);
gst_pad_send_event (pad, eos);
GST_INFO_OBJECT (splitmux, "Sent async EOS on %" GST_PTR_FORMAT, pad);
gst_object_unref (pad);
g_free (helper);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Called with lock held, drops the lock to send EOS to the
* pad
*/
static void
send_eos (GstSplitMuxSink * splitmux, MqStreamCtx * ctx)
{
GstEvent *eos;
GstPad *pad;
eos = gst_event_new_eos ();
pad = gst_pad_get_peer (ctx->srcpad);
ctx->out_eos = TRUE;
GST_INFO_OBJECT (splitmux, "Sending EOS on %" GST_PTR_FORMAT, pad);
GST_SPLITMUX_UNLOCK (splitmux);
gst_pad_send_event (pad, eos);
GST_SPLITMUX_LOCK (splitmux);
gst_object_unref (pad);
}
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
/* Called with lock held. Schedules an EOS event to the ctx pad
* to happen in another thread */
static void
eos_context_async (MqStreamCtx * ctx, GstSplitMuxSink * splitmux)
{
AsyncEosHelper *helper = g_new0 (AsyncEosHelper, 1);
GstPad *srcpad, *sinkpad;
srcpad = ctx->srcpad;
sinkpad = gst_pad_get_peer (srcpad);
helper->ctx = ctx;
helper->pad = sinkpad; /* Takes the reference */
ctx->out_eos_async_done = TRUE;
splitmuxsink: Forward EOS messages from async fragments. Re-enable forwarding EOS messages from fragments that are completing asynchronously, so that splitmuxsink itself won't go EOS until they are complete. This was disabled to work around a bug in core that is fixed in https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/683 Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-28 15:36:35 +00:00
/* There used to be a bug here, where we had to explicitly remove
* the SINK flag so that GstBin would ignore it for EOS purposes.
* That fixed a race where if splitmuxsink really reaches EOS
* before an asynchronous background element has finished, then
* the bin wouldn't actually send EOS to the pipeline. Even after
* finishing and removing the old element, the bin didn't re-check
* EOS status on removing a SINK element. That bug was fixed
* in core. */
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GST_DEBUG_OBJECT (splitmux, "scheduled EOS to pad %" GST_PTR_FORMAT " ctx %p",
sinkpad, ctx);
g_assert_nonnull (helper->pad);
gst_element_call_async (GST_ELEMENT (splitmux),
(GstElementCallAsyncFunc) send_eos_async, helper, NULL);
}
/* Called with lock held. TRUE iff all contexts have a
* pending (or delivered) async eos event */
static gboolean
all_contexts_are_async_eos (GstSplitMuxSink * splitmux)
{
gboolean ret = TRUE;
GList *item;
for (item = splitmux->contexts; item; item = item->next) {
MqStreamCtx *ctx = item->data;
ret &= ctx->out_eos_async_done;
}
return ret;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Called with splitmux lock held to check if this output
* context needs to sleep to wait for the release of the
* next GOP, or to send EOS to close out the current file
*/
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
static GstFlowReturn
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
complete_or_wait_on_out (GstSplitMuxSink * splitmux, MqStreamCtx * ctx)
{
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
if (ctx->caps_change)
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return GST_FLOW_OK;
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
do {
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* When first starting up, the reference stream has to output
* the first buffer to prepare the muxer and sink */
gboolean can_output = (ctx->is_reference || splitmux->ready_for_output);
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
GstClockTimeDiff my_max_out_running_time = splitmux->max_out_running_time;
splitmuxsink: Use GST_CLOCK_STIME_NONE instead of 0 to initialize max out running time Otherwise streams with only DTS would misbehave while it is negative. For outputting everything immediately at EOS, use G_MAXINT64 instead which is bigger-or-equal to any other running time. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 10:11:20 +00:00
if (my_max_out_running_time != GST_CLOCK_STIME_NONE
&& my_max_out_running_time != G_MAXINT64) {
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
my_max_out_running_time -= splitmux->alignment_threshold;
GST_LOG_OBJECT (ctx->srcpad,
"Max out running time currently %" GST_STIME_FORMAT
", with threshold applied it is %" GST_STIME_FORMAT,
GST_STIME_ARGS (splitmux->max_out_running_time),
GST_STIME_ARGS (my_max_out_running_time));
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (ctx->flushing
|| splitmux->output_state == SPLITMUX_OUTPUT_STATE_STOPPED)
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return GST_FLOW_FLUSHING;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_LOG_OBJECT (ctx->srcpad,
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
"Checking running time %" GST_STIME_FORMAT " against max %"
GST_STIME_FORMAT, GST_STIME_ARGS (ctx->out_running_time),
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
GST_STIME_ARGS (my_max_out_running_time));
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (can_output) {
splitmuxsink: Use GST_CLOCK_STIME_NONE instead of 0 to initialize max out running time Otherwise streams with only DTS would misbehave while it is negative. For outputting everything immediately at EOS, use G_MAXINT64 instead which is bigger-or-equal to any other running time. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 10:11:20 +00:00
if (splitmux->max_out_running_time != GST_CLOCK_STIME_NONE &&
splitmuxsink: Add alignment-threshold argument If a non-reference stream is behind the reference stream by an amount of time smaller than the alignment threshold (in nsec), it counts as being after it. https://bugzilla.gnome.org/show_bug.cgi?id=782563
2017-05-12 14:53:57 +00:00
ctx->out_running_time < my_max_out_running_time) {
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return GST_FLOW_OK;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
switch (splitmux->output_state) {
case SPLITMUX_OUTPUT_STATE_OUTPUT_GOP:
/* We only get here if we've finished outputting a GOP and need to know
* what to do next */
splitmux->output_state = SPLITMUX_OUTPUT_STATE_AWAITING_COMMAND;
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
continue;
case SPLITMUX_OUTPUT_STATE_ENDING_FILE:
splitmuxsink: Change EOS catching logic. Add a new state for ending the overall stream, and use it to decide whether to pass the final EOS message up the bus instead of dropping it. Fixes a small race that makes the testsuite sometimes not generate the last fragment(s) sometimes because the wrong EOS gets allowed through too early. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-31 01:49:08 +00:00
case SPLITMUX_OUTPUT_STATE_ENDING_STREAM:
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* We've reached the max out running_time to get here, so end this file now */
if (ctx->out_eos == FALSE) {
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->async_finalize) {
/* We must set EOS asynchronously at this point. We cannot defer
* it, because we need all contexts to wake up, for the
* reference context to eventually give us something at
* START_NEXT_FILE. Otherwise, collectpads might choose another
* context to give us the first buffer, and format-location-full
* will not contain a valid sample. */
g_object_set_qdata ((GObject *) splitmux->sink, EOS_FROM_US,
GINT_TO_POINTER (1));
eos_context_async (ctx, splitmux);
if (all_contexts_are_async_eos (splitmux)) {
GST_INFO_OBJECT (splitmux,
"All contexts are async_eos. Moving to the next file.");
/* We can start the next file once we've asked each pad to go EOS */
splitmux->output_state = SPLITMUX_OUTPUT_STATE_START_NEXT_FILE;
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
continue;
}
} else {
send_eos (splitmux, ctx);
continue;
}
} else {
GST_INFO_OBJECT (splitmux,
"At end-of-file state, but context %p is already EOS", ctx);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
}
break;
case SPLITMUX_OUTPUT_STATE_START_NEXT_FILE:
if (ctx->is_reference) {
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GstFlowReturn ret = GST_FLOW_OK;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* Special handling on the reference ctx to start new fragments
* and collect commands from the command queue */
/* drops the splitmux lock briefly: */
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
/* We must have reference ctx in order for format-location-full to
* have a sample */
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
ret = start_next_fragment (splitmux, ctx);
if (ret != GST_FLOW_OK)
return ret;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
continue;
}
break;
case SPLITMUX_OUTPUT_STATE_AWAITING_COMMAND:{
do {
SplitMuxOutputCommand *cmd =
g_queue_pop_tail (&splitmux->out_cmd_q);
if (cmd != NULL) {
/* If we pop the last command, we need to make our queues bigger */
if (g_queue_get_length (&splitmux->out_cmd_q) == 0)
grow_blocked_queues (splitmux);
if (cmd->start_new_fragment) {
splitmuxsink: Fix for 'reference bytes muxed' check. https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798 introduced a check in the need-new-fragment logic to avoid starting a new fragment unless there has been some data on the reference stream, but the check is done against the number of bytes that have been received on the input, not the number that were released for output into the current fragment. Fix the check to remember and test against bytes that have been sent for output. This also fixes a problem where starting a new fragment fails to request a new filename from the format-location signal. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-12-08 13:40:52 +00:00
if (splitmux->muxed_out_bytes > 0) {
GST_DEBUG_OBJECT (splitmux, "Got cmd to start new fragment");
splitmux->output_state = SPLITMUX_OUTPUT_STATE_ENDING_FILE;
} else {
GST_DEBUG_OBJECT (splitmux,
"Got cmd to start new fragment, but fragment is empty - ignoring.");
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
} else {
GST_DEBUG_OBJECT (splitmux,
"Got new output cmd for time %" GST_STIME_FORMAT,
GST_STIME_ARGS (cmd->max_output_ts));
/* Extend the output range immediately */
splitmuxsink: Only update max in/out running time if it's actually bigger Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 10:02:29 +00:00
if (splitmux->max_out_running_time == GST_CLOCK_STIME_NONE
|| cmd->max_output_ts > splitmux->max_out_running_time)
splitmux->max_out_running_time = cmd->max_output_ts;
GST_DEBUG_OBJECT (splitmux,
"Max out running time now %" GST_STIME_FORMAT,
GST_STIME_ARGS (splitmux->max_out_running_time));
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->output_state = SPLITMUX_OUTPUT_STATE_OUTPUT_GOP;
}
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
out_cmd_buf_free (cmd);
break;
} else {
GST_SPLITMUX_WAIT_OUTPUT (splitmux);
}
splitmuxsink: Make sure flushing doesn't block * Trying to disconnect a stream from a running splitmuxsink by flushing it results in the FLUSH_START blocking in the stream queue's gst_pad_pause_task because the flush did not unblock complete_or_wait_on_out, so add a check for ctx->flushing there. * Add a GST_SPLITMUX_BROADCAST_INPUT so check_completed_gop notices flushing changed and the incoming push is unblocked. * Pass the FLUSH_STOP along to the muxer without waiting. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/687>
2020-07-31 11:50:13 +00:00
} while (!ctx->flushing && splitmux->output_state ==
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
SPLITMUX_OUTPUT_STATE_AWAITING_COMMAND);
/* loop and re-check the state */
continue;
}
case SPLITMUX_OUTPUT_STATE_STOPPED:
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return GST_FLOW_FLUSHING;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Improve debug output Make the debug output less confusing by not mentioning a src pad when doing calculations on the sink pad side. Improve debug around why a GOP is considered overflowing a fragment
2019-05-28 23:20:07 +00:00
} else {
GST_LOG_OBJECT (ctx->srcpad, "Not yet ready for output");
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
GST_INFO_OBJECT (ctx->srcpad,
"Sleeping for running time %"
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_STIME_FORMAT " (max %" GST_STIME_FORMAT ") or state change.",
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
GST_STIME_ARGS (ctx->out_running_time),
GST_STIME_ARGS (splitmux->max_out_running_time));
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_WAIT_OUTPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_INFO_OBJECT (ctx->srcpad,
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
"Woken for new max running time %" GST_STIME_FORMAT,
GST_STIME_ARGS (splitmux->max_out_running_time));
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
}
while (1);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return GST_FLOW_OK;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
static GstClockTime
calculate_next_max_timecode (GstSplitMuxSink * splitmux,
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
const GstVideoTimeCode * cur_tc, GstClockTime running_time,
GstVideoTimeCode ** next_tc)
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
{
GstVideoTimeCode *target_tc;
GstClockTime cur_tc_time, target_tc_time, next_max_tc_time;
splitmuxsink: Take account queued time and max-size-timecode for split decision Not only the requested keyframe time, the queued size should be a criterion for the split decision of timecode based mode (same as max-size-time based split case).
2020-03-24 04:45:00 +00:00
if (cur_tc == NULL || splitmux->tc_interval == NULL)
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
return GST_CLOCK_TIME_NONE;
splitmuxsink: Take account queued time and max-size-timecode for split decision Not only the requested keyframe time, the queued size should be a criterion for the split decision of timecode based mode (same as max-size-time based split case).
2020-03-24 04:45:00 +00:00
target_tc = gst_video_time_code_add_interval (cur_tc, splitmux->tc_interval);
splitmuxsink: Post error when requested timecode interval is invalid In case we cannot rely on max-size-timecode for split decision, post error instead of crashing
2020-04-10 15:35:16 +00:00
if (!target_tc) {
GST_ELEMENT_ERROR (splitmux,
STREAM, FAILED, (NULL), ("Couldn't calculate target timecode"));
return GST_CLOCK_TIME_NONE;
}
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
/* Convert to ns */
target_tc_time = gst_video_time_code_nsec_since_daily_jam (target_tc);
cur_tc_time = gst_video_time_code_nsec_since_daily_jam (cur_tc);
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
/* Add running_time, accounting for wraparound. */
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
if (target_tc_time >= cur_tc_time) {
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
next_max_tc_time = target_tc_time - cur_tc_time + running_time;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
} else {
GstClockTime day_in_ns = 24 * 60 * 60 * GST_SECOND;
splitmuxsink: Fix if condition in drop-frame timecode wrap-around Was previously: if ( x | y && a == b). Changed it into if ((x & y) && (a == b)).
2018-10-11 10:55:01 +00:00
if ((cur_tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME) &&
(cur_tc->config.fps_d == 1001)) {
splitmuxsink: Subtract daily jam offset when day wraps around For drop-frame framerates, when the expected next max timecode wraps around at the end of the day, we have to subtract the offset of the daily jam, otherwise we end up with a duration that's a few frames too long. https://bugzilla.gnome.org/show_bug.cgi?id=797270
2018-10-09 13:39:11 +00:00
/* Checking fps_d is probably unneeded, but better safe than sorry
* (e.g. someone accidentally set a flag) */
splitmuxsink: Do not hardcode frames_of_daily_jam Apart from the obvious drawbacks of hardcoding, the drawback here was that, if we subtracted 2 frames (instead of 2.6) from the target running time, we'd request the next keyframe a bit too far into the future, which would make our files split at the wrong position. https://bugzilla.gnome.org/show_bug.cgi?id=797293
2018-10-16 12:42:12 +00:00
GstVideoTimeCode *tc_for_offset;
/* Here, the duration of the 24:00:00;00 timecode isn't exactly one day,
* but slightly less. Calculate that duration from a fake timecode. The
* problem is that 24:00:00;00 isn't a valid timecode, so the workaround
* is to add one frame to 23:59:59;29 */
tc_for_offset =
gst_video_time_code_new (cur_tc->config.fps_n, cur_tc->config.fps_d,
NULL, cur_tc->config.flags, 23, 59, 59,
cur_tc->config.fps_n / cur_tc->config.fps_d, 0);
day_in_ns =
gst_video_time_code_nsec_since_daily_jam (tc_for_offset) +
gst_util_uint64_scale (GST_SECOND, cur_tc->config.fps_d,
cur_tc->config.fps_n);
gst_video_time_code_free (tc_for_offset);
splitmuxsink: Subtract daily jam offset when day wraps around For drop-frame framerates, when the expected next max timecode wraps around at the end of the day, we have to subtract the offset of the daily jam, otherwise we end up with a duration that's a few frames too long. https://bugzilla.gnome.org/show_bug.cgi?id=797270
2018-10-09 13:39:11 +00:00
}
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
next_max_tc_time = day_in_ns - cur_tc_time + target_tc_time + running_time;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
}
splitmuxsink: Do not hardcode frames_of_daily_jam Apart from the obvious drawbacks of hardcoding, the drawback here was that, if we subtracted 2 frames (instead of 2.6) from the target running time, we'd request the next keyframe a bit too far into the future, which would make our files split at the wrong position. https://bugzilla.gnome.org/show_bug.cgi?id=797293
2018-10-16 12:42:12 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
#ifndef GST_DISABLE_GST_DEBUG
{
gchar *next_max_tc_str, *cur_tc_str;
cur_tc_str = gst_video_time_code_to_string (cur_tc);
next_max_tc_str = gst_video_time_code_to_string (target_tc);
GST_INFO_OBJECT (splitmux, "Next max timecode %s time: %" GST_TIME_FORMAT
" from ref timecode %s time: %" GST_TIME_FORMAT,
next_max_tc_str,
GST_TIME_ARGS (next_max_tc_time),
cur_tc_str, GST_TIME_ARGS (cur_tc_time));
g_free (next_max_tc_str);
g_free (cur_tc_str);
}
#endif
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if (next_tc)
*next_tc = target_tc;
else
gst_video_time_code_free (target_tc);
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
return next_max_tc_time;
}
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
static gboolean
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
request_next_keyframe (GstSplitMuxSink * splitmux, GstBuffer * buffer,
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
GstClockTimeDiff running_time_dts)
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
{
GstEvent *ev;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
GstClockTime target_time;
gboolean timecode_based = FALSE;
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
GstClockTime max_tc_time = GST_CLOCK_TIME_NONE;
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
GstClockTime next_max_tc_time = GST_CLOCK_TIME_NONE;
splitmuxsink: Don't send too many force key unit event splitmuxsink should requst keyframe depending on configured threshold and previously requested time in order to avoid too many keyframe request.
2020-04-03 04:45:56 +00:00
GstClockTime next_fku_time = GST_CLOCK_TIME_NONE;
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
GstClockTime tc_rounding_error = 5 * GST_USECOND;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
InputGop *newest_gop = NULL;
GList *l;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if (!splitmux->send_keyframe_requests)
return TRUE;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
/* Find the newest GOP where we passed in DTS the start PTS */
for (l = splitmux->pending_input_gops.tail; l; l = l->prev) {
InputGop *tmp = l->data;
GST_TRACE_OBJECT (splitmux,
"Having pending input GOP with start PTS %" GST_STIME_FORMAT
" and start time %" GST_STIME_FORMAT,
GST_STIME_ARGS (tmp->start_time_pts), GST_STIME_ARGS (tmp->start_time));
if (tmp->sent_fku) {
GST_DEBUG_OBJECT (splitmux,
"Already checked for a keyframe request for this GOP");
return TRUE;
}
if (running_time_dts == GST_CLOCK_STIME_NONE ||
tmp->start_time_pts == GST_CLOCK_STIME_NONE ||
running_time_dts >= tmp->start_time_pts) {
GST_DEBUG_OBJECT (splitmux,
"Using GOP with start PTS %" GST_STIME_FORMAT " and start time %"
GST_STIME_FORMAT, GST_STIME_ARGS (tmp->start_time_pts),
GST_STIME_ARGS (tmp->start_time));
newest_gop = tmp;
break;
}
}
if (!newest_gop) {
GST_DEBUG_OBJECT (splitmux, "Have no complete enough pending input GOP");
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
return TRUE;
}
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if (splitmux->tc_interval) {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (newest_gop->start_tc
&& gst_video_time_code_is_valid (newest_gop->start_tc)) {
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
GstVideoTimeCode *next_tc = NULL;
max_tc_time =
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
calculate_next_max_timecode (splitmux, newest_gop->start_tc,
newest_gop->start_time, &next_tc);
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
/* calculate the next expected keyframe time to prevent too early fku
* event */
if (GST_CLOCK_TIME_IS_VALID (max_tc_time) && next_tc) {
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
next_max_tc_time =
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
calculate_next_max_timecode (splitmux, next_tc, max_tc_time, NULL);
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
}
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if (next_tc)
gst_video_time_code_free (next_tc);
timecode_based = GST_CLOCK_TIME_IS_VALID (max_tc_time) &&
GST_CLOCK_TIME_IS_VALID (next_max_tc_time);
splitmuxsink: Warn when calculating the next fragment time in timecode mode fails But only if timecode mode is enabled as it will fail all the time otherwise. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1557>
2022-01-24 08:45:33 +00:00
if (!timecode_based) {
GST_WARNING_OBJECT (splitmux,
"Couldn't calculate maximum fragment time for timecode mode");
}
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
} else {
/* This can happen in the presence of GAP events that trigger
* a new fragment start */
GST_WARNING_OBJECT (splitmux,
"No buffer available to calculate next timecode");
}
}
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if ((splitmux->threshold_time == 0 && !timecode_based)
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
|| splitmux->threshold_bytes != 0)
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
return TRUE;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
if (timecode_based) {
/* We might have rounding errors: aim slightly earlier */
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if (max_tc_time >= tc_rounding_error) {
target_time = max_tc_time - tc_rounding_error;
} else {
/* unreliable target time */
GST_DEBUG_OBJECT (splitmux, "tc time %" GST_TIME_FORMAT
" is smaller than allowed rounding error, set it to zero",
GST_TIME_ARGS (max_tc_time));
target_time = 0;
}
if (next_max_tc_time >= tc_rounding_error) {
next_fku_time = next_max_tc_time - tc_rounding_error;
} else {
/* unreliable target time */
GST_DEBUG_OBJECT (splitmux, "next tc time %" GST_TIME_FORMAT
" is smaller than allowed rounding error, set it to zero",
GST_TIME_ARGS (next_max_tc_time));
next_fku_time = 0;
}
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
} else {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
target_time = newest_gop->start_time + splitmux->threshold_time;
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
}
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if (GST_CLOCK_TIME_IS_VALID (splitmux->next_fku_time)) {
GstClockTime allowed_time = splitmux->next_fku_time;
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if (timecode_based) {
if (allowed_time >= tc_rounding_error) {
allowed_time -= tc_rounding_error;
} else {
/* unreliable next force key unit time */
GST_DEBUG_OBJECT (splitmux, "expected next force key unit time %"
GST_TIME_FORMAT
" is smaller than allowed rounding error, set it to zero",
GST_TIME_ARGS (splitmux->next_fku_time));
allowed_time = 0;
}
}
if (target_time < allowed_time) {
GST_LOG_OBJECT (splitmux, "Target time %" GST_TIME_FORMAT
" is smaller than expected next keyframe time %" GST_TIME_FORMAT
", rounding error compensated next keyframe time %" GST_TIME_FORMAT,
GST_TIME_ARGS (target_time),
GST_TIME_ARGS (splitmux->next_fku_time),
GST_TIME_ARGS (allowed_time));
return TRUE;
} else if (allowed_time != splitmux->next_fku_time &&
target_time < splitmux->next_fku_time) {
GST_DEBUG_OBJECT (splitmux, "Target time %" GST_TIME_FORMAT
" is smaller than expected next keyframe time %" GST_TIME_FORMAT
", but the difference is smaller than allowed rounding error",
GST_TIME_ARGS (target_time), GST_TIME_ARGS (splitmux->next_fku_time));
}
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
}
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
if (!timecode_based) {
splitmuxsink: Don't send too many force key unit event splitmuxsink should requst keyframe depending on configured threshold and previously requested time in order to avoid too many keyframe request.
2020-04-03 04:45:56 +00:00
next_fku_time = target_time + splitmux->threshold_time;
splitmuxsink: Take account queued time and max-size-timecode for split decision Not only the requested keyframe time, the queued size should be a criterion for the split decision of timecode based mode (same as max-size-time based split case).
2020-03-24 04:45:00 +00:00
}
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
splitmuxsink: Don't send too many force key unit event splitmuxsink should requst keyframe depending on configured threshold and previously requested time in order to avoid too many keyframe request.
2020-04-03 04:45:56 +00:00
GST_INFO_OBJECT (splitmux, "Requesting keyframe at %" GST_TIME_FORMAT
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
", the next expected keyframe request time is %" GST_TIME_FORMAT,
splitmuxsink: Don't send too many force key unit event splitmuxsink should requst keyframe depending on configured threshold and previously requested time in order to avoid too many keyframe request.
2020-04-03 04:45:56 +00:00
GST_TIME_ARGS (target_time), GST_TIME_ARGS (next_fku_time));
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
newest_gop->sent_fku = TRUE;
splitmux->next_fku_time = next_fku_time;
ev = gst_video_event_new_upstream_force_key_unit (target_time, TRUE, 0);
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
return gst_pad_push_event (splitmux->reference_ctx->sinkpad, ev);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static GstPadProbeReturn
handle_mq_output (GstPad * pad, GstPadProbeInfo * info, MqStreamCtx * ctx)
{
GstSplitMuxSink *splitmux = ctx->splitmux;
MqStreamBuf *buf_info = NULL;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GstFlowReturn ret = GST_FLOW_OK;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Remove stray carriage-return from debug
2016-05-13 11:20:28 +00:00
GST_LOG_OBJECT (pad, "Fired probe type 0x%x", info->type);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* FIXME: Handle buffer lists, until then make it clear they won't work */
if (info->type & GST_PAD_PROBE_TYPE_BUFFER_LIST) {
g_warning ("Buffer list handling not implemented");
return GST_PAD_PROBE_DROP;
}
splitmuxsink: Correctly catch FLUSH events in probes https://bugzilla.gnome.org/show_bug.cgi?id=767498
2017-04-20 10:17:35 +00:00
if (info->type & GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM ||
info->type & GST_PAD_PROBE_TYPE_EVENT_FLUSH) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GstEvent *event = gst_pad_probe_info_get_event (info);
splitmuxsink: Make sure flushing doesn't block * Trying to disconnect a stream from a running splitmuxsink by flushing it results in the FLUSH_START blocking in the stream queue's gst_pad_pause_task because the flush did not unblock complete_or_wait_on_out, so add a check for ctx->flushing there. * Add a GST_SPLITMUX_BROADCAST_INPUT so check_completed_gop notices flushing changed and the incoming push is unblocked. * Pass the FLUSH_STOP along to the muxer without waiting. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/687>
2020-07-31 11:50:13 +00:00
gboolean locked = FALSE, wait = !ctx->is_reference;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_LOG_OBJECT (pad, "Event %" GST_PTR_FORMAT, event);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEGMENT:
gst_event_copy_segment (event, &ctx->out_segment);
break;
case GST_EVENT_FLUSH_STOP:
GST_SPLITMUX_LOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
locked = TRUE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gst_segment_init (&ctx->out_segment, GST_FORMAT_UNDEFINED);
g_queue_foreach (&ctx->queued_bufs, (GFunc) mq_stream_buf_free, NULL);
g_queue_clear (&ctx->queued_bufs);
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
g_queue_clear (&ctx->queued_bufs);
/* If this is the reference context, we just threw away any queued keyframes */
if (ctx->is_reference)
splitmux->queued_keyframes = 0;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
ctx->flushing = FALSE;
splitmuxsink: Make sure flushing doesn't block * Trying to disconnect a stream from a running splitmuxsink by flushing it results in the FLUSH_START blocking in the stream queue's gst_pad_pause_task because the flush did not unblock complete_or_wait_on_out, so add a check for ctx->flushing there. * Add a GST_SPLITMUX_BROADCAST_INPUT so check_completed_gop notices flushing changed and the incoming push is unblocked. * Pass the FLUSH_STOP along to the muxer without waiting. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/687>
2020-07-31 11:50:13 +00:00
wait = FALSE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
case GST_EVENT_FLUSH_START:
GST_SPLITMUX_LOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
locked = TRUE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_LOG_OBJECT (pad, "Flush start");
ctx->flushing = TRUE;
splitmuxsink: Make sure flushing doesn't block * Trying to disconnect a stream from a running splitmuxsink by flushing it results in the FLUSH_START blocking in the stream queue's gst_pad_pause_task because the flush did not unblock complete_or_wait_on_out, so add a check for ctx->flushing there. * Add a GST_SPLITMUX_BROADCAST_INPUT so check_completed_gop notices flushing changed and the incoming push is unblocked. * Pass the FLUSH_STOP along to the muxer without waiting. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/687>
2020-07-31 11:50:13 +00:00
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
case GST_EVENT_EOS:
GST_SPLITMUX_LOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
locked = TRUE;
if (splitmux->output_state == SPLITMUX_OUTPUT_STATE_STOPPED)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto beach;
ctx->out_eos = TRUE;
splitmuxsink: Change EOS catching logic. Add a new state for ending the overall stream, and use it to decide whether to pass the final EOS message up the bus instead of dropping it. Fixes a small race that makes the testsuite sometimes not generate the last fragment(s) sometimes because the wrong EOS gets allowed through too early. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-31 01:49:08 +00:00
if (ctx == splitmux->reference_ctx) {
splitmux->output_state = SPLITMUX_OUTPUT_STATE_ENDING_STREAM;
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
}
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GST_INFO_OBJECT (splitmux,
"Have EOS event at pad %" GST_PTR_FORMAT " ctx %p", pad, ctx);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
case GST_EVENT_GAP:{
GstClockTime gap_ts;
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
GstClockTimeDiff rtime;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gst_event_parse_gap (event, &gap_ts, NULL);
if (gap_ts == GST_CLOCK_TIME_NONE)
break;
GST_SPLITMUX_LOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
locked = TRUE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (splitmux->output_state == SPLITMUX_OUTPUT_STATE_STOPPED)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto beach;
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
/* When we get a gap event on the
* reference stream and we're trying to open a
* new file, we need to store it until we get
* the buffer afterwards
*/
if (ctx->is_reference &&
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
(splitmux->output_state != SPLITMUX_OUTPUT_STATE_OUTPUT_GOP)) {
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
GST_DEBUG_OBJECT (pad, "Storing GAP event until buffer arrives");
gst_event_replace (&ctx->pending_gap, event);
GST_SPLITMUX_UNLOCK (splitmux);
return GST_PAD_PROBE_HANDLED;
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
rtime = my_segment_to_running_time (&ctx->out_segment, gap_ts);
GST_LOG_OBJECT (pad, "Have GAP w/ ts %" GST_STIME_FORMAT,
GST_STIME_ARGS (rtime));
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
if (rtime != GST_CLOCK_STIME_NONE) {
ctx->out_running_time = rtime;
complete_or_wait_on_out (splitmux, ctx);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
}
splitmuxsink: Fix occasional deadlock when ending file with subtitle Deadlock occurs when splitting files if one stream received no buffer during the first GOP of the next file. That can happen in that scenario for example: 1) The first GOP of video is collected, it has a duration of 10s. max_in_running_time is set to 10s. 2) Other streams catchup and we receive the first subtitle buffer at ts=0 and has a duration of 1min. 3) We receive the 2nd subtitle buffer with a ts=1min. in_running_time is set to 1min. That buffer is blocked in handle_mq_input() because max_in_running_time is still 10s. 4) Since all in_running_time are now > 10s, max_out_running_time is now set to 10s. That first GOP gets recorded into the file. The muxer pop buffers out of the mq, when it tries to pop a 2nd subtitle buffer it blocks because the GstDataQueue is empty. 5) A 2nd GOP of video is collected and has a duration of 10s as well. max_in_running_time is now 20s. Since subtitle's in_running_time is already 1min, that GOP is already complete. 6) But let's say we overran the max file size, we thus set state to SPLITMUX_STATE_ENDING_FILE now. As soon as a buffer with ts > 10s (end of previous GOP) arrives in handle_mq_output(), EOS event is sent downstream instead. But since the subtitle queue is empty, that's never going to happen. Pipeline is now deadlocked. To fix this situation we have to: - Send a dummy event through the queue to wakeup output thread. - Update out_running_time to at least max_out_running_time so it sends EOS. - Respect time order, so we set out_running_tim=max_in_running_time because that's bigger than previous buffer and smaller than next. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-18 19:45:01 +00:00
case GST_EVENT_CUSTOM_DOWNSTREAM:{
const GstStructure *s;
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
GstClockTimeDiff ts = 0;
splitmuxsink: Fix occasional deadlock when ending file with subtitle Deadlock occurs when splitting files if one stream received no buffer during the first GOP of the next file. That can happen in that scenario for example: 1) The first GOP of video is collected, it has a duration of 10s. max_in_running_time is set to 10s. 2) Other streams catchup and we receive the first subtitle buffer at ts=0 and has a duration of 1min. 3) We receive the 2nd subtitle buffer with a ts=1min. in_running_time is set to 1min. That buffer is blocked in handle_mq_input() because max_in_running_time is still 10s. 4) Since all in_running_time are now > 10s, max_out_running_time is now set to 10s. That first GOP gets recorded into the file. The muxer pop buffers out of the mq, when it tries to pop a 2nd subtitle buffer it blocks because the GstDataQueue is empty. 5) A 2nd GOP of video is collected and has a duration of 10s as well. max_in_running_time is now 20s. Since subtitle's in_running_time is already 1min, that GOP is already complete. 6) But let's say we overran the max file size, we thus set state to SPLITMUX_STATE_ENDING_FILE now. As soon as a buffer with ts > 10s (end of previous GOP) arrives in handle_mq_output(), EOS event is sent downstream instead. But since the subtitle queue is empty, that's never going to happen. Pipeline is now deadlocked. To fix this situation we have to: - Send a dummy event through the queue to wakeup output thread. - Update out_running_time to at least max_out_running_time so it sends EOS. - Respect time order, so we set out_running_tim=max_in_running_time because that's bigger than previous buffer and smaller than next. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-18 19:45:01 +00:00
s = gst_event_get_structure (event);
if (!gst_structure_has_name (s, "splitmuxsink-unblock"))
break;
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
gst_structure_get_int64 (s, "timestamp", &ts);
splitmuxsink: Fix occasional deadlock when ending file with subtitle Deadlock occurs when splitting files if one stream received no buffer during the first GOP of the next file. That can happen in that scenario for example: 1) The first GOP of video is collected, it has a duration of 10s. max_in_running_time is set to 10s. 2) Other streams catchup and we receive the first subtitle buffer at ts=0 and has a duration of 1min. 3) We receive the 2nd subtitle buffer with a ts=1min. in_running_time is set to 1min. That buffer is blocked in handle_mq_input() because max_in_running_time is still 10s. 4) Since all in_running_time are now > 10s, max_out_running_time is now set to 10s. That first GOP gets recorded into the file. The muxer pop buffers out of the mq, when it tries to pop a 2nd subtitle buffer it blocks because the GstDataQueue is empty. 5) A 2nd GOP of video is collected and has a duration of 10s as well. max_in_running_time is now 20s. Since subtitle's in_running_time is already 1min, that GOP is already complete. 6) But let's say we overran the max file size, we thus set state to SPLITMUX_STATE_ENDING_FILE now. As soon as a buffer with ts > 10s (end of previous GOP) arrives in handle_mq_output(), EOS event is sent downstream instead. But since the subtitle queue is empty, that's never going to happen. Pipeline is now deadlocked. To fix this situation we have to: - Send a dummy event through the queue to wakeup output thread. - Update out_running_time to at least max_out_running_time so it sends EOS. - Respect time order, so we set out_running_tim=max_in_running_time because that's bigger than previous buffer and smaller than next. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-18 19:45:01 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
locked = TRUE;
splitmuxsink: Fix occasional deadlock when ending file with subtitle Deadlock occurs when splitting files if one stream received no buffer during the first GOP of the next file. That can happen in that scenario for example: 1) The first GOP of video is collected, it has a duration of 10s. max_in_running_time is set to 10s. 2) Other streams catchup and we receive the first subtitle buffer at ts=0 and has a duration of 1min. 3) We receive the 2nd subtitle buffer with a ts=1min. in_running_time is set to 1min. That buffer is blocked in handle_mq_input() because max_in_running_time is still 10s. 4) Since all in_running_time are now > 10s, max_out_running_time is now set to 10s. That first GOP gets recorded into the file. The muxer pop buffers out of the mq, when it tries to pop a 2nd subtitle buffer it blocks because the GstDataQueue is empty. 5) A 2nd GOP of video is collected and has a duration of 10s as well. max_in_running_time is now 20s. Since subtitle's in_running_time is already 1min, that GOP is already complete. 6) But let's say we overran the max file size, we thus set state to SPLITMUX_STATE_ENDING_FILE now. As soon as a buffer with ts > 10s (end of previous GOP) arrives in handle_mq_output(), EOS event is sent downstream instead. But since the subtitle queue is empty, that's never going to happen. Pipeline is now deadlocked. To fix this situation we have to: - Send a dummy event through the queue to wakeup output thread. - Update out_running_time to at least max_out_running_time so it sends EOS. - Respect time order, so we set out_running_tim=max_in_running_time because that's bigger than previous buffer and smaller than next. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-18 19:45:01 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (splitmux->output_state == SPLITMUX_OUTPUT_STATE_STOPPED)
splitmuxsink: Fix occasional deadlock when ending file with subtitle Deadlock occurs when splitting files if one stream received no buffer during the first GOP of the next file. That can happen in that scenario for example: 1) The first GOP of video is collected, it has a duration of 10s. max_in_running_time is set to 10s. 2) Other streams catchup and we receive the first subtitle buffer at ts=0 and has a duration of 1min. 3) We receive the 2nd subtitle buffer with a ts=1min. in_running_time is set to 1min. That buffer is blocked in handle_mq_input() because max_in_running_time is still 10s. 4) Since all in_running_time are now > 10s, max_out_running_time is now set to 10s. That first GOP gets recorded into the file. The muxer pop buffers out of the mq, when it tries to pop a 2nd subtitle buffer it blocks because the GstDataQueue is empty. 5) A 2nd GOP of video is collected and has a duration of 10s as well. max_in_running_time is now 20s. Since subtitle's in_running_time is already 1min, that GOP is already complete. 6) But let's say we overran the max file size, we thus set state to SPLITMUX_STATE_ENDING_FILE now. As soon as a buffer with ts > 10s (end of previous GOP) arrives in handle_mq_output(), EOS event is sent downstream instead. But since the subtitle queue is empty, that's never going to happen. Pipeline is now deadlocked. To fix this situation we have to: - Send a dummy event through the queue to wakeup output thread. - Update out_running_time to at least max_out_running_time so it sends EOS. - Respect time order, so we set out_running_tim=max_in_running_time because that's bigger than previous buffer and smaller than next. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-18 19:45:01 +00:00
goto beach;
ctx->out_running_time = ts;
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
if (!ctx->is_reference)
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
ret = complete_or_wait_on_out (splitmux, ctx);
splitmuxsink: Fix occasional deadlock when ending file with subtitle Deadlock occurs when splitting files if one stream received no buffer during the first GOP of the next file. That can happen in that scenario for example: 1) The first GOP of video is collected, it has a duration of 10s. max_in_running_time is set to 10s. 2) Other streams catchup and we receive the first subtitle buffer at ts=0 and has a duration of 1min. 3) We receive the 2nd subtitle buffer with a ts=1min. in_running_time is set to 1min. That buffer is blocked in handle_mq_input() because max_in_running_time is still 10s. 4) Since all in_running_time are now > 10s, max_out_running_time is now set to 10s. That first GOP gets recorded into the file. The muxer pop buffers out of the mq, when it tries to pop a 2nd subtitle buffer it blocks because the GstDataQueue is empty. 5) A 2nd GOP of video is collected and has a duration of 10s as well. max_in_running_time is now 20s. Since subtitle's in_running_time is already 1min, that GOP is already complete. 6) But let's say we overran the max file size, we thus set state to SPLITMUX_STATE_ENDING_FILE now. As soon as a buffer with ts > 10s (end of previous GOP) arrives in handle_mq_output(), EOS event is sent downstream instead. But since the subtitle queue is empty, that's never going to happen. Pipeline is now deadlocked. To fix this situation we have to: - Send a dummy event through the queue to wakeup output thread. - Update out_running_time to at least max_out_running_time so it sends EOS. - Respect time order, so we set out_running_tim=max_in_running_time because that's bigger than previous buffer and smaller than next. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-18 19:45:01 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_PAD_PROBE_INFO_FLOW_RETURN (info) = ret;
splitmuxsink: Fix occasional deadlock when ending file with subtitle Deadlock occurs when splitting files if one stream received no buffer during the first GOP of the next file. That can happen in that scenario for example: 1) The first GOP of video is collected, it has a duration of 10s. max_in_running_time is set to 10s. 2) Other streams catchup and we receive the first subtitle buffer at ts=0 and has a duration of 1min. 3) We receive the 2nd subtitle buffer with a ts=1min. in_running_time is set to 1min. That buffer is blocked in handle_mq_input() because max_in_running_time is still 10s. 4) Since all in_running_time are now > 10s, max_out_running_time is now set to 10s. That first GOP gets recorded into the file. The muxer pop buffers out of the mq, when it tries to pop a 2nd subtitle buffer it blocks because the GstDataQueue is empty. 5) A 2nd GOP of video is collected and has a duration of 10s as well. max_in_running_time is now 20s. Since subtitle's in_running_time is already 1min, that GOP is already complete. 6) But let's say we overran the max file size, we thus set state to SPLITMUX_STATE_ENDING_FILE now. As soon as a buffer with ts > 10s (end of previous GOP) arrives in handle_mq_output(), EOS event is sent downstream instead. But since the subtitle queue is empty, that's never going to happen. Pipeline is now deadlocked. To fix this situation we have to: - Send a dummy event through the queue to wakeup output thread. - Update out_running_time to at least max_out_running_time so it sends EOS. - Respect time order, so we set out_running_tim=max_in_running_time because that's bigger than previous buffer and smaller than next. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-18 19:45:01 +00:00
return GST_PAD_PROBE_DROP;
}
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
case GST_EVENT_CAPS:{
GstPad *peer;
if (!ctx->is_reference)
break;
peer = gst_pad_get_peer (pad);
if (peer) {
gboolean ok = gst_pad_send_event (peer, gst_event_ref (event));
gst_object_unref (peer);
if (ok)
break;
splitmux: Fix file switch-on-caps-change. Switching to a new fragment because the input caps have changed didn't properly end the previous file. Use the normal EOS sequence to ensure that happens. Add a test that it works.
2017-11-24 05:56:03 +00:00
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
} else {
break;
}
/* This is in the case the muxer doesn't allow this change of caps */
GST_SPLITMUX_LOCK (splitmux);
locked = TRUE;
ctx->caps_change = TRUE;
if (splitmux->output_state != SPLITMUX_OUTPUT_STATE_START_NEXT_FILE) {
splitmux: Fix file switch-on-caps-change. Switching to a new fragment because the input caps have changed didn't properly end the previous file. Use the normal EOS sequence to ensure that happens. Add a test that it works.
2017-11-24 05:56:03 +00:00
GST_DEBUG_OBJECT (splitmux,
"New caps were not accepted. Switching output file");
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
if (ctx->out_eos == FALSE) {
splitmux: Fix file switch-on-caps-change. Switching to a new fragment because the input caps have changed didn't properly end the previous file. Use the normal EOS sequence to ensure that happens. Add a test that it works.
2017-11-24 05:56:03 +00:00
splitmux->output_state = SPLITMUX_OUTPUT_STATE_ENDING_FILE;
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
}
}
/* Lets it fall through, if it fails again, then the muxer just can't
* support this format, but at least we have a closed file.
*/
break;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
default:
break;
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* We need to make sure events aren't passed
* until the muxer / sink are ready for it */
if (!locked)
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Make sure flushing doesn't block * Trying to disconnect a stream from a running splitmuxsink by flushing it results in the FLUSH_START blocking in the stream queue's gst_pad_pause_task because the flush did not unblock complete_or_wait_on_out, so add a check for ctx->flushing there. * Add a GST_SPLITMUX_BROADCAST_INPUT so check_completed_gop notices flushing changed and the incoming push is unblocked. * Pass the FLUSH_STOP along to the muxer without waiting. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/687>
2020-07-31 11:50:13 +00:00
if (wait)
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
ret = complete_or_wait_on_out (splitmux, ctx);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
/* Don't try to forward sticky events before the next buffer is there
* because it would cause a new file to be created without the first
* buffer being available.
*/
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_PAD_PROBE_INFO_FLOW_RETURN (info) = ret;
splitmux: Fix file switch-on-caps-change. Switching to a new fragment because the input caps have changed didn't properly end the previous file. Use the normal EOS sequence to ensure that happens. Add a test that it works.
2017-11-24 05:56:03 +00:00
if (ctx->caps_change && GST_EVENT_IS_STICKY (event)) {
gst_event_unref (event);
return GST_PAD_PROBE_HANDLED;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
} else {
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
return GST_PAD_PROBE_PASS;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
/* Allow everything through until the configured next stopping point */
GST_SPLITMUX_LOCK (splitmux);
buf_info = g_queue_pop_tail (&ctx->queued_bufs);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
if (buf_info == NULL) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Can only happen due to a poorly timed flush */
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
ret = GST_FLOW_FLUSHING;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto beach;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* If we have popped a keyframe, decrement the queued_gop count */
splitmuxsink: Only count keyframes for the reference context, consistently Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 09:53:12 +00:00
if (buf_info->keyframe && splitmux->queued_keyframes > 0 && ctx->is_reference)
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->queued_keyframes--;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
ctx->out_running_time = buf_info->run_ts;
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
ctx->cur_out_buffer = gst_pad_probe_info_get_buffer (info);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_LOG_OBJECT (splitmux,
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
"Pad %" GST_PTR_FORMAT " buffer with run TS %" GST_STIME_FORMAT
Fixed splitmuxsink 32-bit overflow bug Extend the byte tracking counters to 64-bit on all platforms, instead of using gsize, which overflows after 4GB. https://bugzilla.gnome.org/show_bug.cgi?id=770019
2016-08-20 08:59:30 +00:00
" size %" G_GUINT64_FORMAT,
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
pad, GST_STIME_ARGS (ctx->out_running_time), buf_info->buf_size);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
ctx->caps_change = FALSE;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
ret = complete_or_wait_on_out (splitmux, ctx);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux->muxed_out_bytes += buf_info->buf_size;
#ifndef GST_DISABLE_GST_DEBUG
{
GstBuffer *buf = gst_pad_probe_info_get_buffer (info);
GST_LOG_OBJECT (pad, "Returning to pass buffer %" GST_PTR_FORMAT
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
" run ts %" GST_STIME_FORMAT, buf,
GST_STIME_ARGS (ctx->out_running_time));
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
#endif
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
ctx->cur_out_buffer = NULL;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
/* pending_gap is protected by the STREAM lock */
if (ctx->pending_gap) {
/* If we previously stored a gap event, send it now */
GstPad *peer = gst_pad_get_peer (ctx->srcpad);
GST_DEBUG_OBJECT (splitmux,
"Pad %" GST_PTR_FORMAT " sending pending GAP event", ctx->srcpad);
gst_pad_send_event (peer, ctx->pending_gap);
ctx->pending_gap = NULL;
gst_object_unref (peer);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
mq_stream_buf_free (buf_info);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_PAD_PROBE_INFO_FLOW_RETURN (info) = ret;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
return GST_PAD_PROBE_PASS;
beach:
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_PAD_PROBE_INFO_FLOW_RETURN (info) = ret;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
return GST_PAD_PROBE_DROP;
}
static gboolean
resend_sticky (GstPad * pad, GstEvent ** event, GstPad * peer)
{
return gst_pad_send_event (peer, gst_event_ref (*event));
}
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
static void
unlock_context (MqStreamCtx * ctx, GstSplitMuxSink * splitmux)
{
if (ctx->fragment_block_id > 0) {
gst_pad_remove_probe (ctx->srcpad, ctx->fragment_block_id);
ctx->fragment_block_id = 0;
}
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static void
restart_context (MqStreamCtx * ctx, GstSplitMuxSink * splitmux)
{
GstPad *peer = gst_pad_get_peer (ctx->srcpad);
gst_pad_sticky_events_foreach (ctx->srcpad,
(GstPadStickyEventsForeachFunction) (resend_sticky), peer);
splitmux: Handle a hang draining out at EOS Make sure that all data is drained out when the reference pad goes EOS. Fixes a problem where data that arrives on other pads after the reference pad finishes can stall forever and never pass EOS. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-30 15:15:04 +00:00
/* Clear EOS flag if not actually EOS */
ctx->out_eos = GST_PAD_IS_EOS (ctx->srcpad);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
ctx->out_eos_async_done = ctx->out_eos;
splitmux: Add unit test for file splitting Add a unit test for file splitting, and fix the leaks in the splitmuxsink it found
2015-02-06 14:41:49 +00:00
gst_object_unref (peer);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
static void
relink_context (MqStreamCtx * ctx, GstSplitMuxSink * splitmux)
{
GstPad *sinkpad, *srcpad, *newpad;
GstPadTemplate *templ;
srcpad = ctx->srcpad;
sinkpad = gst_pad_get_peer (srcpad);
templ = sinkpad->padtemplate;
newpad =
gst_element_request_pad (splitmux->muxer, templ,
splitmuxsink: In async mode, retain previous muxer pad names. When running in async-finalize mode, request new pads from the muxer using the same names as old pads, instead of letting the muxer assign new ones based on the pad template name.
2019-07-25 16:21:59 +00:00
GST_PAD_NAME (sinkpad), NULL);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GST_DEBUG_OBJECT (splitmux, "Relinking ctx %p to pad %" GST_PTR_FORMAT, ctx,
newpad);
if (!gst_pad_unlink (srcpad, sinkpad)) {
gst_object_unref (sinkpad);
goto fail;
}
if (gst_pad_link_full (srcpad, newpad,
GST_PAD_LINK_CHECK_NO_RECONFIGURE) != GST_PAD_LINK_OK) {
gst_element_release_request_pad (splitmux->muxer, newpad);
gst_object_unref (sinkpad);
gst_object_unref (newpad);
goto fail;
}
gst_object_unref (newpad);
gst_object_unref (sinkpad);
return;
fail:
GST_ELEMENT_ERROR (splitmux, RESOURCE, SETTINGS,
("Could not create the new muxer/sink"), NULL);
}
static GstPadProbeReturn
_block_pad (GstPad * pad, GstPadProbeInfo * info, gpointer user_data)
{
return GST_PAD_PROBE_OK;
}
static void
block_context (MqStreamCtx * ctx, GstSplitMuxSink * splitmux)
{
ctx->fragment_block_id =
gst_pad_add_probe (ctx->srcpad, GST_PAD_PROBE_TYPE_BLOCK, _block_pad,
NULL, NULL);
}
static gboolean
_set_property_from_structure (GQuark field_id, const GValue * value,
gpointer user_data)
{
const gchar *property_name = g_quark_to_string (field_id);
GObject *element = G_OBJECT (user_data);
g_object_set_property (element, property_name, value);
return TRUE;
}
static void
_lock_and_set_to_null (GstElement * element, GstSplitMuxSink * splitmux)
{
gst_element_set_locked_state (element, TRUE);
gst_element_set_state (element, GST_STATE_NULL);
GST_LOG_OBJECT (splitmux, "Removing old element %" GST_PTR_FORMAT, element);
gst_bin_remove (GST_BIN (splitmux), element);
}
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
static void
_send_event (const GValue * value, gpointer user_data)
{
GstPad *pad = g_value_get_object (value);
GstEvent *ev = user_data;
gst_pad_send_event (pad, gst_event_ref (ev));
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Called with lock held when a fragment
* reaches EOS and it is time to restart
* a new fragment
*/
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
static GstFlowReturn
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
start_next_fragment (GstSplitMuxSink * splitmux, MqStreamCtx * ctx)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
{
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GstElement *muxer, *sink;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
g_assert (ctx->is_reference);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* 1 change to new file */
Revert "splitmuxsink: Use GstBin async-handling instead of our own." This reverts commit fa008f271a52f82dededc28bd81b020ca7939b47. async-handling in GstBin causes the pipeline to spin at 100% CPU as the top-level pipeline tries to change that state to PLAYING constantly. This is a workaround for a core problem, essentially, but an improvement in this case for now.
2016-08-07 16:53:48 +00:00
splitmux->switching_fragment = TRUE;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* We need to drop the splitmux lock to acquire the state lock
* here and ensure there's no racy state change going on elsewhere */
muxer = gst_object_ref (splitmux->muxer);
sink = gst_object_ref (splitmux->active_sink);
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
GST_SPLITMUX_STATE_LOCK (splitmux);
if (splitmux->shutdown) {
GST_DEBUG_OBJECT (splitmux,
"Shutdown requested. Aborting fragment switch.");
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
GST_SPLITMUX_STATE_UNLOCK (splitmux);
splitmuxsink: Fix some reference leaks in error cases. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-26 07:55:24 +00:00
gst_object_unref (muxer);
gst_object_unref (sink);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return GST_FLOW_FLUSHING;
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->async_finalize) {
splitmuxsink: provides a start-index property Allow to change the fragment-id start index.
2019-12-05 14:58:40 +00:00
if (splitmux->muxed_out_bytes > 0
|| splitmux->fragment_id != splitmux->start_index) {
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
gchar *newname;
GstElement *new_sink, *new_muxer;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GST_DEBUG_OBJECT (splitmux, "Starting fragment %u",
splitmux->fragment_id);
g_list_foreach (splitmux->contexts, (GFunc) block_context, splitmux);
newname = g_strdup_printf ("sink_%u", splitmux->fragment_id);
GST_SPLITMUX_LOCK (splitmux);
if ((splitmux->sink =
create_element (splitmux, splitmux->sink_factory, newname,
TRUE)) == NULL)
goto fail;
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
if (splitmux->sink_preset && GST_IS_PRESET (splitmux->sink))
gst_preset_load_preset (GST_PRESET (splitmux->sink),
splitmux->sink_preset);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->sink_properties)
gst_structure_foreach (splitmux->sink_properties,
_set_property_from_structure, splitmux->sink);
splitmux->active_sink = splitmux->sink;
g_signal_emit (splitmux, signals[SIGNAL_SINK_ADDED], 0, splitmux->sink);
g_free (newname);
newname = g_strdup_printf ("muxer_%u", splitmux->fragment_id);
if ((splitmux->muxer =
create_element (splitmux, splitmux->muxer_factory, newname,
TRUE)) == NULL)
goto fail;
if (g_object_class_find_property (G_OBJECT_GET_CLASS (splitmux->sink),
"async") != NULL) {
/* async child elements are causing state change races and weird
* failures, so let's try and turn that off */
g_object_set (splitmux->sink, "async", FALSE, NULL);
}
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
if (splitmux->muxer_preset && GST_IS_PRESET (splitmux->muxer))
gst_preset_load_preset (GST_PRESET (splitmux->muxer),
splitmux->muxer_preset);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->muxer_properties)
gst_structure_foreach (splitmux->muxer_properties,
_set_property_from_structure, splitmux->muxer);
g_signal_emit (splitmux, signals[SIGNAL_MUXER_ADDED], 0, splitmux->muxer);
g_free (newname);
new_sink = splitmux->sink;
new_muxer = splitmux->muxer;
GST_SPLITMUX_UNLOCK (splitmux);
g_list_foreach (splitmux->contexts, (GFunc) relink_context, splitmux);
gst_element_link (new_muxer, new_sink);
if (g_object_get_qdata ((GObject *) sink, EOS_FROM_US)) {
if (GPOINTER_TO_INT (g_object_get_qdata ((GObject *) sink,
EOS_FROM_US)) == 2) {
_lock_and_set_to_null (muxer, splitmux);
_lock_and_set_to_null (sink, splitmux);
} else {
g_object_set_qdata ((GObject *) sink, EOS_FROM_US,
GINT_TO_POINTER (2));
}
}
splitmuxsink: Don't leak old muxer/sink in async mode Make sure to clear the reference taken earlier in the function when switching muxer/sink asynchronously so they don't leak
2018-08-14 16:28:20 +00:00
gst_object_unref (muxer);
gst_object_unref (sink);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
muxer = new_muxer;
sink = new_sink;
gst_object_ref (muxer);
gst_object_ref (sink);
}
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
} else {
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
gst_element_set_locked_state (muxer, TRUE);
gst_element_set_locked_state (sink, TRUE);
gst_element_set_state (sink, GST_STATE_NULL);
if (splitmux->reset_muxer) {
gst_element_set_state (muxer, GST_STATE_NULL);
} else {
GstIterator *it = gst_element_iterate_sink_pads (muxer);
GstEvent *ev;
splitmuxsink: set the same seqnum on flush_start / flush_stop It's currently not made mandatory by aggregator, but it might eventually be, and is more consistent behaviour See https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/977
2019-05-22 19:40:52 +00:00
guint32 seqnum;
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
ev = gst_event_new_flush_start ();
splitmuxsink: set the same seqnum on flush_start / flush_stop It's currently not made mandatory by aggregator, but it might eventually be, and is more consistent behaviour See https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/977
2019-05-22 19:40:52 +00:00
seqnum = gst_event_get_seqnum (ev);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
while (gst_iterator_foreach (it, _send_event, ev) == GST_ITERATOR_RESYNC);
gst_event_unref (ev);
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
gst_iterator_resync (it);
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
ev = gst_event_new_flush_stop (TRUE);
splitmuxsink: set the same seqnum on flush_start / flush_stop It's currently not made mandatory by aggregator, but it might eventually be, and is more consistent behaviour See https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/977
2019-05-22 19:40:52 +00:00
gst_event_set_seqnum (ev, seqnum);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
while (gst_iterator_foreach (it, _send_event, ev) == GST_ITERATOR_RESYNC);
gst_event_unref (ev);
gst_iterator_free (it);
}
splitmuxsink: Add new reset-muxer property With this the muxer is not set to NULL after each segment but instead only flush events are sent to it to reset the EOS state. As a result, the muxer will keep stream state and e.g. mpegtsmux will keep the packet continuity counter continuous between segments as needed by hlssink2. https://bugzilla.gnome.org/show_bug.cgi?id=794816
2018-03-29 16:19:21 +00:00
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Fix for 'reference bytes muxed' check. https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798 introduced a check in the need-new-fragment logic to avoid starting a new fragment unless there has been some data on the reference stream, but the check is done against the number of bytes that have been received on the input, not the number that were released for output into the current fragment. Fix the check to remember and test against bytes that have been sent for output. This also fixes a problem where starting a new fragment fails to request a new filename from the format-location signal. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-12-08 13:40:52 +00:00
set_next_filename (splitmux, ctx);
splitmuxsink: Change files on incompatible caps https://bugzilla.gnome.org/show_bug.cgi?id=761761
2017-02-15 19:48:58 +00:00
splitmux->muxed_out_bytes = 0;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
if (gst_element_set_state (sink,
GST_STATE_TARGET (splitmux)) == GST_STATE_CHANGE_FAILURE) {
gst_element_set_state (sink, GST_STATE_NULL);
gst_element_set_locked_state (muxer, FALSE);
gst_element_set_locked_state (sink, FALSE);
goto fail_output;
}
if (gst_element_set_state (muxer,
GST_STATE_TARGET (splitmux)) == GST_STATE_CHANGE_FAILURE) {
gst_element_set_state (muxer, GST_STATE_NULL);
gst_element_set_state (sink, GST_STATE_NULL);
gst_element_set_locked_state (muxer, FALSE);
gst_element_set_locked_state (sink, FALSE);
goto fail_muxer;
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
gst_element_set_locked_state (muxer, FALSE);
gst_element_set_locked_state (sink, FALSE);
splitmuxsink: Hide internal async state changes. When switching fragments, hide the async-start/async-done messages from the parent bin, as otherwise we sometimes (very rarely) hang in PAUSED instead of returning / continuing to PLAYING state.
2016-05-14 08:32:52 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
gst_object_unref (sink);
gst_object_unref (muxer);
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
GST_SPLITMUX_STATE_UNLOCK (splitmux);
Revert "splitmuxsink: Use GstBin async-handling instead of our own." This reverts commit fa008f271a52f82dededc28bd81b020ca7939b47. async-handling in GstBin causes the pipeline to spin at 100% CPU as the top-level pipeline tries to change that state to PLAYING constantly. This is a workaround for a core problem, essentially, but an improvement in this case for now.
2016-08-07 16:53:48 +00:00
splitmux->switching_fragment = FALSE;
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
do_async_done (splitmux);
Revert "splitmuxsink: Use GstBin async-handling instead of our own." This reverts commit fa008f271a52f82dededc28bd81b020ca7939b47. async-handling in GstBin causes the pipeline to spin at 100% CPU as the top-level pipeline tries to change that state to PLAYING constantly. This is a workaround for a core problem, essentially, but an improvement in this case for now.
2016-08-07 16:53:48 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->ready_for_output = TRUE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
g_list_foreach (splitmux->contexts, (GFunc) unlock_context, splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
g_list_foreach (splitmux->contexts, (GFunc) restart_context, splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
send_fragment_opened_closed_msg (splitmux, TRUE, sink);
splitmuxsink: post messages when fragments are being opened and closed This can be useful for applications that need to track the created fragments (to log them in a recording database, for example) https://bugzilla.gnome.org/show_bug.cgi?id=750108
2015-04-17 12:25:43 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* FIXME: Is this always the correct next state? */
splitmuxsink: Improve debug output Make the debug output less confusing by not mentioning a src pad when doing calculations on the sink pad side. Improve debug around why a GOP is considered overflowing a fragment
2019-05-28 23:20:07 +00:00
GST_LOG_OBJECT (splitmux, "Resetting state to AWAITING_COMMAND");
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->output_state = SPLITMUX_OUTPUT_STATE_AWAITING_COMMAND;
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return GST_FLOW_OK;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
fail:
splitmuxsink: Fix some reference leaks in error cases. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-26 07:55:24 +00:00
gst_object_unref (sink);
gst_object_unref (muxer);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
GST_SPLITMUX_STATE_UNLOCK (splitmux);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GST_ELEMENT_ERROR (splitmux, RESOURCE, SETTINGS,
("Could not create the new muxer/sink"), NULL);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return GST_FLOW_ERROR;
fail_output:
GST_ELEMENT_ERROR (splitmux, RESOURCE, SETTINGS,
("Could not start new output sink"), NULL);
splitmuxsink: Fix some reference leaks in error cases. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-26 07:55:24 +00:00
gst_object_unref (sink);
gst_object_unref (muxer);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_SPLITMUX_LOCK (splitmux);
GST_SPLITMUX_STATE_UNLOCK (splitmux);
splitmux->switching_fragment = FALSE;
return GST_FLOW_ERROR;
fail_muxer:
GST_ELEMENT_ERROR (splitmux, RESOURCE, SETTINGS,
("Could not start new muxer"), NULL);
splitmuxsink: Fix some reference leaks in error cases. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-26 07:55:24 +00:00
gst_object_unref (sink);
gst_object_unref (muxer);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_SPLITMUX_LOCK (splitmux);
GST_SPLITMUX_STATE_UNLOCK (splitmux);
splitmux->switching_fragment = FALSE;
return GST_FLOW_ERROR;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
static void
bus_handler (GstBin * bin, GstMessage * message)
{
GstSplitMuxSink *splitmux = GST_SPLITMUX_SINK (bin);
switch (GST_MESSAGE_TYPE (message)) {
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
case GST_MESSAGE_EOS:{
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* If the state is draining out the current file, drop this EOS */
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GstElement *sink;
splitmuxsink: post messages when fragments are being opened and closed This can be useful for applications that need to track the created fragments (to log them in a recording database, for example) https://bugzilla.gnome.org/show_bug.cgi?id=750108
2015-04-17 12:25:43 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
sink = GST_ELEMENT (GST_MESSAGE_SRC (message));
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: post messages when fragments are being opened and closed This can be useful for applications that need to track the created fragments (to log them in a recording database, for example) https://bugzilla.gnome.org/show_bug.cgi?id=750108
2015-04-17 12:25:43 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
send_fragment_opened_closed_msg (splitmux, FALSE, sink);
if (splitmux->async_finalize) {
if (g_object_get_qdata ((GObject *) sink, EOS_FROM_US)) {
if (GPOINTER_TO_INT (g_object_get_qdata ((GObject *) sink,
EOS_FROM_US)) == 2) {
GstElement *muxer;
GstPad *sinksink, *muxersrc;
sinksink = gst_element_get_static_pad (sink, "sink");
muxersrc = gst_pad_get_peer (sinksink);
muxer = gst_pad_get_parent_element (muxersrc);
gst_object_unref (sinksink);
gst_object_unref (muxersrc);
gst_element_call_async (muxer,
(GstElementCallAsyncFunc) _lock_and_set_to_null,
gst_object_ref (splitmux), gst_object_unref);
gst_element_call_async (sink,
(GstElementCallAsyncFunc) _lock_and_set_to_null,
gst_object_ref (splitmux), gst_object_unref);
gst_object_unref (muxer);
} else {
g_object_set_qdata ((GObject *) sink, EOS_FROM_US,
GINT_TO_POINTER (2));
}
GST_DEBUG_OBJECT (splitmux,
"Caught async EOS from previous muxer+sink. Dropping.");
/* We forward the EOS so that it gets aggregated as normal. If the sink
* finishes and is removed before the end, it will be de-aggregated */
gst_message_unref (message);
GST_SPLITMUX_UNLOCK (splitmux);
return;
}
splitmuxsink: Change EOS catching logic. Add a new state for ending the overall stream, and use it to decide whether to pass the final EOS message up the bus instead of dropping it. Fixes a small race that makes the testsuite sometimes not generate the last fragment(s) sometimes because the wrong EOS gets allowed through too early. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-31 01:49:08 +00:00
} else if (splitmux->output_state == SPLITMUX_OUTPUT_STATE_ENDING_STREAM) {
GST_DEBUG_OBJECT (splitmux,
"Passing EOS message. Output state %d max_out_running_time %"
GST_STIME_FORMAT, splitmux->output_state,
GST_STIME_ARGS (splitmux->max_out_running_time));
} else {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_DEBUG_OBJECT (splitmux, "Caught EOS at end of fragment, dropping");
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->output_state = SPLITMUX_OUTPUT_STATE_START_NEXT_FILE;
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
Revert "splitmuxsink: Mask async-start/done while switching files." This reverts commit d61e5393f110ed482815d77807245d78b52eff46. Causes failures muxing larger GOP sizes for some reason. Reverting while I figure it out
2015-06-23 06:28:40 +00:00
gst_message_unref (message);
GST_SPLITMUX_UNLOCK (splitmux);
return;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
GST_SPLITMUX_UNLOCK (splitmux);
break;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
}
Revert "splitmuxsink: Use GstBin async-handling instead of our own." This reverts commit fa008f271a52f82dededc28bd81b020ca7939b47. async-handling in GstBin causes the pipeline to spin at 100% CPU as the top-level pipeline tries to change that state to PLAYING constantly. This is a workaround for a core problem, essentially, but an improvement in this case for now.
2016-08-07 16:53:48 +00:00
case GST_MESSAGE_ASYNC_START:
case GST_MESSAGE_ASYNC_DONE:
/* Ignore state changes from our children while switching */
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GST_SPLITMUX_LOCK (splitmux);
Revert "splitmuxsink: Use GstBin async-handling instead of our own." This reverts commit fa008f271a52f82dededc28bd81b020ca7939b47. async-handling in GstBin causes the pipeline to spin at 100% CPU as the top-level pipeline tries to change that state to PLAYING constantly. This is a workaround for a core problem, essentially, but an improvement in this case for now.
2016-08-07 16:53:48 +00:00
if (splitmux->switching_fragment) {
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (GST_MESSAGE_SRC (message) == (GstObject *) splitmux->active_sink
|| GST_MESSAGE_SRC (message) == (GstObject *) splitmux->muxer) {
Revert "splitmuxsink: Use GstBin async-handling instead of our own." This reverts commit fa008f271a52f82dededc28bd81b020ca7939b47. async-handling in GstBin causes the pipeline to spin at 100% CPU as the top-level pipeline tries to change that state to PLAYING constantly. This is a workaround for a core problem, essentially, but an improvement in this case for now.
2016-08-07 16:53:48 +00:00
GST_LOG_OBJECT (splitmux,
"Ignoring state change from child %" GST_PTR_FORMAT
" while switching", GST_MESSAGE_SRC (message));
gst_message_unref (message);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
Revert "splitmuxsink: Use GstBin async-handling instead of our own." This reverts commit fa008f271a52f82dededc28bd81b020ca7939b47. async-handling in GstBin causes the pipeline to spin at 100% CPU as the top-level pipeline tries to change that state to PLAYING constantly. This is a workaround for a core problem, essentially, but an improvement in this case for now.
2016-08-07 16:53:48 +00:00
return;
}
}
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
Revert "splitmuxsink: Use GstBin async-handling instead of our own." This reverts commit fa008f271a52f82dededc28bd81b020ca7939b47. async-handling in GstBin causes the pipeline to spin at 100% CPU as the top-level pipeline tries to change that state to PLAYING constantly. This is a workaround for a core problem, essentially, but an improvement in this case for now.
2016-08-07 16:53:48 +00:00
break;
qtmux: send stream warning when refusing video caps If codec_data is changed, the stream is no longer valid. Rather than keeping running when refusing new caps, this patch send a warning to the bus. Also fix up splitmuxsink to ignore this warning while changing caps. https://bugzilla.gnome.org/show_bug.cgi?id=790000
2017-12-04 11:12:40 +00:00
case GST_MESSAGE_WARNING:
{
GError *gerror = NULL;
gst_message_parse_warning (message, &gerror, NULL);
if (g_error_matches (gerror, GST_STREAM_ERROR, GST_STREAM_ERROR_FORMAT)) {
GList *item;
gboolean caps_change = FALSE;
GST_SPLITMUX_LOCK (splitmux);
for (item = splitmux->contexts; item; item = item->next) {
MqStreamCtx *ctx = item->data;
if (ctx->caps_change) {
caps_change = TRUE;
break;
}
}
GST_SPLITMUX_UNLOCK (splitmux);
if (caps_change) {
GST_LOG_OBJECT (splitmux,
"Ignoring warning change from child %" GST_PTR_FORMAT
" while switching caps", GST_MESSAGE_SRC (message));
gst_message_unref (message);
return;
}
}
break;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
default:
break;
}
GST_BIN_CLASS (parent_class)->handle_message (bin, message);
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
static void
ctx_set_unblock (MqStreamCtx * ctx)
{
ctx->need_unblock = TRUE;
}
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
static gboolean
need_new_fragment (GstSplitMuxSink * splitmux,
GstClockTime queued_time, GstClockTime queued_gop_time,
guint64 queued_bytes)
{
guint64 thresh_bytes;
GstClockTime thresh_time;
gboolean check_robust_muxing;
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
GstClockTime time_to_split = GST_CLOCK_TIME_NONE;
GstClockTime *ptr_to_time;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
const InputGop *gop, *next_gop;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
GST_OBJECT_LOCK (splitmux);
thresh_bytes = splitmux->threshold_bytes;
thresh_time = splitmux->threshold_time;
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
ptr_to_time = (GstClockTime *)
gst_queue_array_peek_head_struct (splitmux->times_to_split);
if (ptr_to_time)
time_to_split = *ptr_to_time;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
check_robust_muxing = splitmux->use_robust_muxing
&& splitmux->muxer_has_reserved_props;
GST_OBJECT_UNLOCK (splitmux);
splitmuxsink: Never start a new fragment with no reference buffers If there has been no bytes from the reference stream muxed into the current fragment, then time can't have advanced, there's no GOP... this fragment would be broken or empty, so wait for some data on the reference buffer. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-09-17 12:56:01 +00:00
/* Have we muxed at least one thing from the reference
* stream into the file? If not, no other streams can have
* either */
splitmuxsink: Fix for 'reference bytes muxed' check. https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798 introduced a check in the need-new-fragment logic to avoid starting a new fragment unless there has been some data on the reference stream, but the check is done against the number of bytes that have been received on the input, not the number that were released for output into the current fragment. Fix the check to remember and test against bytes that have been sent for output. This also fixes a problem where starting a new fragment fails to request a new filename from the format-location signal. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-12-08 13:40:52 +00:00
if (splitmux->fragment_reference_bytes <= 0) {
GST_TRACE_OBJECT (splitmux,
"Not ready to split - nothing muxed on the reference stream");
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
return FALSE;
splitmuxsink: Fix for 'reference bytes muxed' check. https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798 introduced a check in the need-new-fragment logic to avoid starting a new fragment unless there has been some data on the reference stream, but the check is done against the number of bytes that have been received on the input, not the number that were released for output into the current fragment. Fix the check to remember and test against bytes that have been sent for output. This also fixes a problem where starting a new fragment fails to request a new filename from the format-location signal. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-12-08 13:40:52 +00:00
}
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
/* User told us to split now */
splitmuxsink: Improve debug output Make the debug output less confusing by not mentioning a src pad when doing calculations on the sink pad side. Improve debug around why a GOP is considered overflowing a fragment
2019-05-28 23:20:07 +00:00
if (g_atomic_int_get (&(splitmux->do_split_next_gop)) == TRUE) {
GST_TRACE_OBJECT (splitmux, "Forcing because split_next_gop is set");
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
return TRUE;
splitmuxsink: Improve debug output Make the debug output less confusing by not mentioning a src pad when doing calculations on the sink pad side. Improve debug around why a GOP is considered overflowing a fragment
2019-05-28 23:20:07 +00:00
}
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
gop = g_queue_peek_head (&splitmux->pending_input_gops);
/* We need a full GOP queued up at this point */
g_assert (gop != NULL);
next_gop = g_queue_peek_nth (&splitmux->pending_input_gops, 1);
/* And the beginning of the next GOP or otherwise EOS */
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
/* User told us to split at this running time */
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (gop->start_time >= time_to_split) {
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
GST_OBJECT_LOCK (splitmux);
/* Dequeue running time */
gst_queue_array_pop_head_struct (splitmux->times_to_split);
/* Empty any running times after this that are past now */
ptr_to_time = gst_queue_array_peek_head_struct (splitmux->times_to_split);
while (ptr_to_time) {
time_to_split = *ptr_to_time;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (gop->start_time < time_to_split) {
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
break;
}
gst_queue_array_pop_head_struct (splitmux->times_to_split);
ptr_to_time = gst_queue_array_peek_head_struct (splitmux->times_to_split);
}
splitmuxsink: Fix for 'reference bytes muxed' check. https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798 introduced a check in the need-new-fragment logic to avoid starting a new fragment unless there has been some data on the reference stream, but the check is done against the number of bytes that have been received on the input, not the number that were released for output into the current fragment. Fix the check to remember and test against bytes that have been sent for output. This also fixes a problem where starting a new fragment fails to request a new filename from the format-location signal. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-12-08 13:40:52 +00:00
GST_TRACE_OBJECT (splitmux,
"GOP start time %" GST_STIME_FORMAT " is after requested split point %"
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GST_STIME_FORMAT, GST_STIME_ARGS (gop->start_time),
splitmuxsink: Fix for 'reference bytes muxed' check. https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798 introduced a check in the need-new-fragment logic to avoid starting a new fragment unless there has been some data on the reference stream, but the check is done against the number of bytes that have been received on the input, not the number that were released for output into the current fragment. Fix the check to remember and test against bytes that have been sent for output. This also fixes a problem where starting a new fragment fails to request a new filename from the format-location signal. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-12-08 13:40:52 +00:00
GST_STIME_ARGS (time_to_split));
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
GST_OBJECT_UNLOCK (splitmux);
return TRUE;
}
splitmuxsink: Improve debug output Make the debug output less confusing by not mentioning a src pad when doing calculations on the sink pad side. Improve debug around why a GOP is considered overflowing a fragment
2019-05-28 23:20:07 +00:00
if (thresh_bytes > 0 && queued_bytes > thresh_bytes) {
GST_TRACE_OBJECT (splitmux,
"queued bytes %" G_GUINT64_FORMAT " overruns byte limit", queued_bytes);
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
return TRUE; /* Would overrun byte limit */
splitmuxsink: Improve debug output Make the debug output less confusing by not mentioning a src pad when doing calculations on the sink pad side. Improve debug around why a GOP is considered overflowing a fragment
2019-05-28 23:20:07 +00:00
}
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
splitmuxsink: Improve debug output Make the debug output less confusing by not mentioning a src pad when doing calculations on the sink pad side. Improve debug around why a GOP is considered overflowing a fragment
2019-05-28 23:20:07 +00:00
if (thresh_time > 0 && queued_time > thresh_time) {
GST_TRACE_OBJECT (splitmux,
"queued time %" GST_STIME_FORMAT " overruns time limit",
GST_STIME_ARGS (queued_time));
return TRUE; /* Would overrun time limit */
}
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (splitmux->tc_interval) {
GstClockTime next_gop_start_time =
next_gop ? next_gop->start_time : splitmux->max_in_running_time;
if (GST_CLOCK_TIME_IS_VALID (splitmux->next_fragment_start_tc_time) &&
GST_CLOCK_STIME_IS_VALID (next_gop_start_time) &&
next_gop_start_time >
splitmux->next_fragment_start_tc_time + 5 * GST_USECOND) {
GST_TRACE_OBJECT (splitmux,
"in running time %" GST_STIME_FORMAT " overruns time limit %"
GST_TIME_FORMAT, GST_STIME_ARGS (next_gop_start_time),
GST_TIME_ARGS (splitmux->next_fragment_start_tc_time));
return TRUE;
}
splitmuxsink: Improve debug output Make the debug output less confusing by not mentioning a src pad when doing calculations on the sink pad side. Improve debug around why a GOP is considered overflowing a fragment
2019-05-28 23:20:07 +00:00
}
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
if (check_robust_muxing) {
GstClockTime mux_reserved_remain;
g_object_get (splitmux->muxer,
"reserved-duration-remaining", &mux_reserved_remain, NULL);
GST_LOG_OBJECT (splitmux,
"Muxer robust muxing report - %" G_GUINT64_FORMAT
" remaining. New GOP would enqueue %" G_GUINT64_FORMAT,
mux_reserved_remain, queued_gop_time);
if (queued_gop_time >= mux_reserved_remain) {
GST_INFO_OBJECT (splitmux,
"File is about to run out of header room - %" G_GUINT64_FORMAT
" remaining. New GOP would enqueue %" G_GUINT64_FORMAT
". Switching to new file", mux_reserved_remain, queued_gop_time);
return TRUE;
}
}
/* Continue and mux this GOP */
return FALSE;
}
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
/* probably we want to add this API? */
static void
video_time_code_replace (GstVideoTimeCode ** old_tc, GstVideoTimeCode * new_tc)
{
GstVideoTimeCode *timecode = NULL;
g_return_if_fail (old_tc != NULL);
if (*old_tc == new_tc)
return;
if (new_tc)
timecode = gst_video_time_code_copy (new_tc);
if (*old_tc)
gst_video_time_code_free (*old_tc);
*old_tc = timecode;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Called with splitmux lock held */
/* Called when entering ProcessingCompleteGop state
* Assess if mq contents overflowed the current file
* -> If yes, need to switch to new file
* -> if no, set max_out_running_time to let this GOP in and
* go to COLLECTING_GOP_START state
*/
static void
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
handle_gathered_gop (GstSplitMuxSink * splitmux, const InputGop * gop,
GstClockTimeDiff next_gop_start_time, GstClockTimeDiff max_out_running_time)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
{
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
guint64 queued_bytes;
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
GstClockTimeDiff queued_time = 0;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
GstClockTimeDiff queued_gop_time = 0;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
SplitMuxOutputCommand *cmd;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Assess if the multiqueue contents overflowed the current file */
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* When considering if a newly gathered GOP overflows
* the time limit for the file, only consider the running time of the
* reference stream. Other streams might have run ahead a little bit,
* but extra pieces won't be released to the muxer beyond the reference
* stream cut-off anyway - so it forms the limit. */
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
queued_bytes = splitmux->fragment_total_bytes + gop->total_bytes;
queued_time = next_gop_start_time;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
/* queued_gop_time tracks how much unwritten data there is waiting to
* be written to this fragment including this GOP */
if (splitmux->reference_ctx->out_running_time != GST_CLOCK_STIME_NONE)
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
queued_gop_time = queued_time - splitmux->reference_ctx->out_running_time;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
else
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
queued_gop_time = queued_time - gop->start_time;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_LOG_OBJECT (splitmux, " queued_bytes %" G_GUINT64_FORMAT, queued_bytes);
splitmuxsink: Convert asserts into element errors. Change some g_assert into element errors so that they can be caught and the pipeline shut down. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-08-18 06:06:14 +00:00
GST_LOG_OBJECT (splitmux, "mq at TS %" GST_STIME_FORMAT
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
" bytes %" G_GUINT64_FORMAT " in next gop start time %" GST_STIME_FORMAT
splitmuxsink: Convert asserts into element errors. Change some g_assert into element errors so that they can be caught and the pipeline shut down. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-08-18 06:06:14 +00:00
" gop start time %" GST_STIME_FORMAT,
GST_STIME_ARGS (queued_time), queued_bytes,
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GST_STIME_ARGS (next_gop_start_time), GST_STIME_ARGS (gop->start_time));
splitmuxsink: Convert asserts into element errors. Change some g_assert into element errors so that they can be caught and the pipeline shut down. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-08-18 06:06:14 +00:00
if (queued_gop_time < 0)
goto error_gop_duration;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Convert asserts into element errors. Change some g_assert into element errors so that they can be caught and the pipeline shut down. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-08-18 06:06:14 +00:00
if (queued_time < splitmux->fragment_start_time)
goto error_queued_time;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
queued_time -= splitmux->fragment_start_time;
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
if (queued_time < queued_gop_time)
queued_gop_time = queued_time;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Expand queued bytes estimate by muxer overhead */
queued_bytes += (queued_bytes * splitmux->mux_overhead);
/* Check for overrun - have we output at least one byte and overrun
* either threshold? */
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
if (need_new_fragment (splitmux, queued_time, queued_gop_time, queued_bytes)) {
splitmuxsink: Only set running time on finalizing sink element when in async-finalize mode There is only a single sink element in async-finalize mode, and we would keep the running time from previous fragments set in that case. As we don't ever set the running time for the very last fragment on EOS, this would mean that the closing time reported for the very last fragment is the same as the closing time of the previous fragment.
2019-05-22 15:06:04 +00:00
if (splitmux->async_finalize) {
GstClockTime *sink_running_time = g_new (GstClockTime, 1);
*sink_running_time = splitmux->reference_ctx->out_running_time;
g_object_set_qdata_full (G_OBJECT (splitmux->sink),
RUNNING_TIME, sink_running_time, g_free);
}
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
g_atomic_int_set (&(splitmux->do_split_next_gop), FALSE);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* Tell the output side to start a new fragment */
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_INFO_OBJECT (splitmux,
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
"This GOP (dur %" GST_STIME_FORMAT
") would overflow the fragment, Sending start_new_fragment cmd",
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GST_STIME_ARGS (queued_gop_time));
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
cmd = out_cmd_buf_new ();
cmd->start_new_fragment = TRUE;
g_queue_push_head (&splitmux->out_cmd_q, cmd);
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
splitmux->fragment_start_time = gop->start_time;
splitmux->fragment_start_time_pts = gop->start_time_pts;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->fragment_total_bytes = 0;
splitmuxsink: Never start a new fragment with no reference buffers If there has been no bytes from the reference stream muxed into the current fragment, then time can't have advanced, there's no GOP... this fragment would be broken or empty, so wait for some data on the reference buffer. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-09-17 12:56:01 +00:00
splitmux->fragment_reference_bytes = 0;
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
video_time_code_replace (&splitmux->fragment_start_tc, gop->start_tc);
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmux->next_fragment_start_tc_time =
calculate_next_max_timecode (splitmux, splitmux->fragment_start_tc,
splitmux->fragment_start_time, NULL);
splitmuxsink: Warn when calculating the next fragment time in timecode mode fails But only if timecode mode is enabled as it will fail all the time otherwise. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1557>
2022-01-24 08:45:33 +00:00
if (splitmux->tc_interval && splitmux->fragment_start_tc
&& !GST_CLOCK_TIME_IS_VALID (splitmux->next_fragment_start_tc_time)) {
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
GST_WARNING_OBJECT (splitmux,
"Couldn't calculate next fragment start time for timecode mode");
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* And set up to collect the next GOP */
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (max_out_running_time != G_MAXINT64) {
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->input_state = SPLITMUX_INPUT_STATE_COLLECTING_GOP_START;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
} else {
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* This is probably already the current state, but just in case: */
splitmux->input_state = SPLITMUX_INPUT_STATE_FINISHING_UP;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* And wake all input contexts to send a wake-up event */
g_list_foreach (splitmux->contexts, (GFunc) ctx_set_unblock, NULL);
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
splitmuxsink: Take released-but-not-yet-output bytes into account When deciding whether it's time to switch to a new file, take into account data that's been released for pushing, but hasn't yet been pushed - because downstream is slow or the threads haven't been scheduled. Fixes a race in the unit test and probably in practice - sometimes failing to switch when it should for an extra GOP or two. Also fix a problem in splitmuxsrc where playback sometimes stalls at startup if types are found too quickly. https://bugzilla.gnome.org/show_bug.cgi?id=750747
2015-06-11 03:36:54 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* Now either way - either there was no overflow, or we requested a new fragment: release this GOP */
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
splitmux->fragment_total_bytes += gop->total_bytes;
splitmux->fragment_reference_bytes += gop->reference_bytes;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (gop->total_bytes > 0) {
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_LOG_OBJECT (splitmux,
"Releasing GOP to output. Bytes in fragment now %" G_GUINT64_FORMAT
" time %" GST_STIME_FORMAT,
splitmux->fragment_total_bytes, GST_STIME_ARGS (queued_time));
/* Send this GOP to the output command queue */
cmd = out_cmd_buf_new ();
cmd->start_new_fragment = FALSE;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
cmd->max_output_ts = max_out_running_time;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_LOG_OBJECT (splitmux, "Sending GOP cmd to output for TS %"
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GST_STIME_FORMAT, GST_STIME_ARGS (max_out_running_time));
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
g_queue_push_head (&splitmux->out_cmd_q, cmd);
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Convert asserts into element errors. Change some g_assert into element errors so that they can be caught and the pipeline shut down. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/833>
2020-08-18 06:06:14 +00:00
return;
error_gop_duration:
GST_ELEMENT_ERROR (splitmux,
STREAM, FAILED, ("Timestamping error on input streams"),
("Queued GOP time is negative %" GST_STIME_FORMAT,
GST_STIME_ARGS (queued_gop_time)));
return;
error_queued_time:
GST_ELEMENT_ERROR (splitmux,
STREAM, FAILED, ("Timestamping error on input streams"),
("Queued time is negative. Input went backwards. queued_time - %"
GST_STIME_FORMAT, GST_STIME_ARGS (queued_time)));
return;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
/* Called with splitmux lock held */
/* Called from each input pad when it is has all the pieces
splitmuxsink: allow non-video streams to serve as reference In the absence of a video stream, the first stream will be used as reference. https://bugzilla.gnome.org/show_bug.cgi?id=753617
2015-04-29 17:23:28 +00:00
* for a GOP or EOS, starting with the reference pad which has set the
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
* splitmux->max_in_running_time
*/
static void
check_completed_gop (GstSplitMuxSink * splitmux, MqStreamCtx * ctx)
{
GList *cur;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GstEvent *event;
/* On ENDING_FILE, the reference stream sends a command to start a new
* fragment, then releases the GOP for output in the new fragment.
documentation: fix a number of typos
2019-09-02 12:27:35 +00:00
* If some streams received no buffer during the last GOP that overran,
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
* because its next buffer has a timestamp bigger than
* ctx->max_in_running_time, its queue is empty. In that case the only
* way to wakeup the output thread is by injecting an event in the
* queue. This usually happen with subtitle streams.
* See https://bugzilla.gnome.org/show_bug.cgi?id=763711. */
if (ctx->need_unblock) {
GST_LOG_OBJECT (ctx->sinkpad, "Sending splitmuxsink-unblock event");
event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM |
GST_EVENT_TYPE_SERIALIZED,
gst_structure_new ("splitmuxsink-unblock", "timestamp",
G_TYPE_INT64, splitmux->max_in_running_time, NULL));
GST_SPLITMUX_UNLOCK (splitmux);
gst_pad_send_event (ctx->sinkpad, event);
GST_SPLITMUX_LOCK (splitmux);
ctx->need_unblock = FALSE;
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
/* state may have changed while we were unlocked. Loop again if so */
if (splitmux->input_state != SPLITMUX_INPUT_STATE_WAITING_GOP_COLLECT)
return;
}
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
do {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GstClockTimeDiff next_gop_start = GST_CLOCK_STIME_NONE;
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
if (splitmux->input_state == SPLITMUX_INPUT_STATE_WAITING_GOP_COLLECT) {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GstClockTimeDiff max_out_running_time;
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
gboolean ready = TRUE;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
InputGop *gop;
const InputGop *next_gop;
gop = g_queue_peek_head (&splitmux->pending_input_gops);
next_gop = g_queue_peek_nth (&splitmux->pending_input_gops, 1);
/* If we have no GOP or no next GOP here then the reference context is
* at EOS, otherwise use the start time of the next GOP if we're far
* enough in the GOP to know it */
if (gop && next_gop) {
if (!splitmux->reference_ctx->in_eos
&& splitmux->max_in_running_time_dts != GST_CLOCK_STIME_NONE
&& splitmux->max_in_running_time_dts < next_gop->start_time_pts) {
GST_LOG_OBJECT (splitmux,
"No further GOPs finished collecting, waiting until current DTS %"
GST_STIME_FORMAT " has passed next GOP start PTS %"
GST_STIME_FORMAT,
GST_STIME_ARGS (splitmux->max_in_running_time_dts),
GST_STIME_ARGS (next_gop->start_time_pts));
break;
}
GST_LOG_OBJECT (splitmux,
"Finished collecting GOP with start time %" GST_STIME_FORMAT
", next GOP start time %" GST_STIME_FORMAT,
GST_STIME_ARGS (gop->start_time),
GST_STIME_ARGS (next_gop->start_time));
next_gop_start = next_gop->start_time;
max_out_running_time =
splitmux->reference_ctx->in_eos ? G_MAXINT64 : next_gop->start_time;
} else if (!next_gop) {
GST_LOG_OBJECT (splitmux, "Reference context is EOS");
next_gop_start = splitmux->max_in_running_time;
max_out_running_time = G_MAXINT64;
} else if (!gop) {
GST_LOG_OBJECT (splitmux, "No further GOPs finished collecting");
break;
} else {
g_assert_not_reached ();
}
g_assert (gop != NULL);
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
/* Iterate each pad, and check that the input running time is at least
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
* up to the start running time of the next GOP or EOS, and if so handle
* the collected GOP */
GST_LOG_OBJECT (splitmux, "Checking GOP collected, next GOP start %"
GST_STIME_FORMAT " ctx %p", GST_STIME_ARGS (next_gop_start), ctx);
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
for (cur = g_list_first (splitmux->contexts); cur != NULL;
cur = g_list_next (cur)) {
MqStreamCtx *tmpctx = (MqStreamCtx *) (cur->data);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_LOG_OBJECT (splitmux,
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
"Context %p sink pad %" GST_PTR_FORMAT " @ TS %" GST_STIME_FORMAT
" EOS %d", tmpctx, tmpctx->sinkpad,
GST_STIME_ARGS (tmpctx->in_running_time), tmpctx->in_eos);
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (next_gop_start != GST_CLOCK_STIME_NONE &&
tmpctx->in_running_time < next_gop_start && !tmpctx->in_eos) {
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
GST_LOG_OBJECT (splitmux,
"Context %p sink pad %" GST_PTR_FORMAT " not ready. We'll sleep",
tmpctx, tmpctx->sinkpad);
ready = FALSE;
break;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
if (ready) {
GST_DEBUG_OBJECT (splitmux,
"Collected GOP is complete. Processing (ctx %p)", ctx);
/* All pads have a complete GOP, release it into the multiqueue */
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
handle_gathered_gop (splitmux, gop, next_gop_start,
max_out_running_time);
g_queue_pop_head (&splitmux->pending_input_gops);
input_gop_free (gop);
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
/* The user has requested a split, we can split now that the previous GOP
* has been collected to the correct location */
if (g_atomic_int_compare_and_exchange (&(splitmux->split_requested),
TRUE, FALSE)) {
g_atomic_int_set (&(splitmux->do_split_next_gop), TRUE);
}
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
/* If upstream reached EOS we are not expecting more data, no need to wait
* here. */
if (ctx->in_eos)
return;
splitmuxsink: Fix deadlock case when source reaches EOS https://bugzilla.gnome.org/show_bug.cgi?id=765072
2016-05-04 15:15:20 +00:00
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
if (splitmux->input_state == SPLITMUX_INPUT_STATE_WAITING_GOP_COLLECT &&
!ctx->flushing &&
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
ctx->in_running_time >= next_gop_start &&
next_gop_start != GST_CLOCK_STIME_NONE) {
splitmuxsink: Don't busy loop on a non-ready pad. If a pad gets into the check_completed_gop method and then the underlying conditions change on the reference context, things could get stuck in a busy loop when the context should instead jump back out and wait for more data. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-29 16:38:15 +00:00
/* Some pad is not yet ready, or GOP is being pushed
* either way, sleep and wait to get woken */
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
GST_LOG_OBJECT (splitmux, "Sleeping for GOP collection (ctx %p)", ctx);
GST_SPLITMUX_WAIT_INPUT (splitmux);
GST_LOG_OBJECT (splitmux, "Done waiting for complete GOP (ctx %p)", ctx);
splitmuxsink: Don't busy loop on a non-ready pad. If a pad gets into the check_completed_gop method and then the underlying conditions change on the reference context, things could get stuck in a busy loop when the context should instead jump back out and wait for more data. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-29 16:38:15 +00:00
} else {
/* This pad is not ready or the state changed - break out and get another
* buffer / event */
break;
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
}
} while (splitmux->input_state == SPLITMUX_INPUT_STATE_WAITING_GOP_COLLECT);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
static GstPadProbeReturn
handle_mq_input (GstPad * pad, GstPadProbeInfo * info, MqStreamCtx * ctx)
{
GstSplitMuxSink *splitmux = ctx->splitmux;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GstFlowReturn ret = GST_FLOW_OK;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GstBuffer *buf;
splitmux: fix memory leak If execution goes to the beach in line 981, buf_info goes out of scope without the memory being free'd. Handle this case. CID #1268403
2015-02-10 13:29:32 +00:00
MqStreamBuf *buf_info = NULL;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
GstClockTime ts, pts, dts;
GstClockTimeDiff running_time, running_time_pts, running_time_dts;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gboolean loop_again;
gboolean keyframe = FALSE;
splitmuxsink: remove extra \n at debug message
2015-08-03 16:45:59 +00:00
GST_LOG_OBJECT (pad, "Fired probe type 0x%x", info->type);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* FIXME: Handle buffer lists, until then make it clear they won't work */
if (info->type & GST_PAD_PROBE_TYPE_BUFFER_LIST) {
g_warning ("Buffer list handling not implemented");
return GST_PAD_PROBE_DROP;
}
splitmuxsink: Correctly catch FLUSH events in probes https://bugzilla.gnome.org/show_bug.cgi?id=767498
2017-04-20 10:17:35 +00:00
if (info->type & GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM ||
info->type & GST_PAD_PROBE_TYPE_EVENT_FLUSH) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GstEvent *event = gst_pad_probe_info_get_event (info);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_LOG_OBJECT (pad, "Event %" GST_PTR_FORMAT, event);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEGMENT:
gst_event_copy_segment (event, &ctx->in_segment);
break;
case GST_EVENT_FLUSH_STOP:
GST_SPLITMUX_LOCK (splitmux);
gst_segment_init (&ctx->in_segment, GST_FORMAT_UNDEFINED);
ctx->in_eos = FALSE;
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
ctx->in_running_time = GST_CLOCK_STIME_NONE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
break;
case GST_EVENT_EOS:
GST_SPLITMUX_LOCK (splitmux);
ctx->in_eos = TRUE;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
if (splitmux->input_state == SPLITMUX_INPUT_STATE_STOPPED) {
ret = GST_FLOW_FLUSHING;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto beach;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: allow non-video streams to serve as reference In the absence of a video stream, the first stream will be used as reference. https://bugzilla.gnome.org/show_bug.cgi?id=753617
2015-04-29 17:23:28 +00:00
if (ctx->is_reference) {
GST_INFO_OBJECT (splitmux, "Got Reference EOS. Finishing up");
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* check_completed_gop will act as if this is a new keyframe with infinite timestamp */
splitmux->input_state = SPLITMUX_INPUT_STATE_WAITING_GOP_COLLECT;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Wake up other input pads to collect this GOP */
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
check_completed_gop (splitmux, ctx);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
} else if (splitmux->input_state ==
SPLITMUX_INPUT_STATE_WAITING_GOP_COLLECT) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* If we are waiting for a GOP to be completed (ie, for aux
* pads to catch up), then this pad is complete, so check
* if the whole GOP is.
*/
check_completed_gop (splitmux, ctx);
}
GST_SPLITMUX_UNLOCK (splitmux);
break;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
case GST_EVENT_GAP:{
GstClockTime gap_ts;
GstClockTimeDiff rtime;
gst_event_parse_gap (event, &gap_ts, NULL);
if (gap_ts == GST_CLOCK_TIME_NONE)
break;
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
if (splitmux->input_state == SPLITMUX_INPUT_STATE_STOPPED) {
ret = GST_FLOW_FLUSHING;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
goto beach;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
rtime = my_segment_to_running_time (&ctx->in_segment, gap_ts);
GST_LOG_OBJECT (pad, "Have GAP w/ ts %" GST_STIME_FORMAT,
GST_STIME_ARGS (rtime));
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (ctx->is_reference && GST_CLOCK_STIME_IS_VALID (rtime)) {
/* If this GAP event happens before the first fragment then
* initialize the fragment start time here. */
if (!GST_CLOCK_STIME_IS_VALID (splitmux->fragment_start_time)) {
splitmux->fragment_start_time = rtime;
GST_LOG_OBJECT (splitmux,
"Fragment start time now %" GST_STIME_FORMAT,
GST_STIME_ARGS (splitmux->fragment_start_time));
/* Also take this as the first start time when starting up,
* so that we start counting overflow from the first frame */
if (!GST_CLOCK_STIME_IS_VALID (splitmux->max_in_running_time))
splitmux->max_in_running_time = rtime;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (!GST_CLOCK_STIME_IS_VALID (splitmux->max_in_running_time_dts))
splitmux->max_in_running_time_dts = rtime;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
}
/* Similarly take it as fragment start PTS and GOP start time if
* these are not set */
if (!GST_CLOCK_STIME_IS_VALID (splitmux->fragment_start_time_pts))
splitmux->fragment_start_time_pts = rtime;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (g_queue_is_empty (&splitmux->pending_input_gops)) {
InputGop *gop = g_slice_new0 (InputGop);
gop->from_gap = TRUE;
gop->start_time = rtime;
gop->start_time_pts = rtime;
g_queue_push_tail (&splitmux->pending_input_gops, gop);
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
}
GST_SPLITMUX_UNLOCK (splitmux);
break;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
default:
break;
}
return GST_PAD_PROBE_PASS;
splitmux: Drop allocation queries They can cause us to deadlock, while we're waiting for a new frame and upstream is waiting for the allocation query to be answered before sending a frame https://bugzilla.gnome.org/show_bug.cgi?id=783753
2017-06-13 14:40:19 +00:00
} else if (info->type & GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM) {
switch (GST_QUERY_TYPE (GST_QUERY (info->data))) {
case GST_QUERY_ALLOCATION:
return GST_PAD_PROBE_DROP;
default:
return GST_PAD_PROBE_PASS;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
buf = gst_pad_probe_info_get_buffer (info);
buf_info = mq_stream_buf_new ();
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
pts = GST_BUFFER_PTS (buf);
dts = GST_BUFFER_DTS (buf);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
if (GST_BUFFER_PTS_IS_VALID (buf))
ts = GST_BUFFER_PTS (buf);
else
ts = GST_BUFFER_DTS (buf);
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
GST_LOG_OBJECT (pad,
"Buffer TS is %" GST_TIME_FORMAT " (PTS %" GST_TIME_FORMAT ", DTS %"
GST_TIME_FORMAT ")", GST_TIME_ARGS (ts), GST_TIME_ARGS (pts),
GST_TIME_ARGS (dts));
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
if (splitmux->input_state == SPLITMUX_INPUT_STATE_STOPPED) {
ret = GST_FLOW_FLUSHING;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto beach;
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* If this buffer has a timestamp, advance the input timestamp of the
* stream */
if (GST_CLOCK_TIME_IS_VALID (ts)) {
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
running_time = my_segment_to_running_time (&ctx->in_segment, ts);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
GST_LOG_OBJECT (pad, "Buffer running TS is %" GST_STIME_FORMAT,
GST_STIME_ARGS (running_time));
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
/* in running time is always the maximum PTS (or DTS) that was observed so far */
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
if (GST_CLOCK_STIME_IS_VALID (running_time)
&& running_time > ctx->in_running_time)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
ctx->in_running_time = running_time;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
} else {
running_time = ctx->in_running_time;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (GST_CLOCK_TIME_IS_VALID (pts))
running_time_pts = my_segment_to_running_time (&ctx->in_segment, pts);
else
running_time_pts = GST_CLOCK_STIME_NONE;
if (GST_CLOCK_TIME_IS_VALID (dts))
running_time_dts = my_segment_to_running_time (&ctx->in_segment, dts);
else
running_time_dts = GST_CLOCK_STIME_NONE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Try to make sure we have a valid running time */
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
if (!GST_CLOCK_STIME_IS_VALID (ctx->in_running_time)) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
ctx->in_running_time =
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
my_segment_to_running_time (&ctx->in_segment, ctx->in_segment.start);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
GST_LOG_OBJECT (pad, "in running time now %" GST_STIME_FORMAT,
GST_STIME_ARGS (ctx->in_running_time));
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
buf_info->run_ts = ctx->in_running_time;
buf_info->buf_size = gst_buffer_get_size (buf);
splitmuxsink: Add option to split at exactly max-size-time Will try to request a keyframe from the encoder to be sent at the target running time. https://bugzilla.gnome.org/show_bug.cgi?id=769664
2016-08-09 09:55:59 +00:00
buf_info->duration = GST_BUFFER_DURATION (buf);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
if (ctx->is_reference) {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
InputGop *gop = NULL;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
GstVideoTimeCodeMeta *tc_meta = gst_buffer_get_video_time_code_meta (buf);
/* initialize fragment_start_time if it was not set yet (i.e. for the
* first fragment), or otherwise set it to the minimum observed time */
if (!GST_CLOCK_STIME_IS_VALID (splitmux->fragment_start_time)
|| splitmux->fragment_start_time > running_time) {
if (!GST_CLOCK_STIME_IS_VALID (splitmux->fragment_start_time))
splitmux->fragment_start_time_pts = running_time_pts;
splitmux->fragment_start_time = running_time;
GST_LOG_OBJECT (splitmux,
"Fragment start time now %" GST_STIME_FORMAT " (initial PTS %"
GST_STIME_FORMAT ")", GST_STIME_ARGS (splitmux->fragment_start_time),
GST_STIME_ARGS (splitmux->fragment_start_time_pts));
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
/* Also take this as the first start time when starting up,
* so that we start counting overflow from the first frame */
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (!GST_CLOCK_STIME_IS_VALID (splitmux->max_in_running_time)
|| splitmux->max_in_running_time < splitmux->fragment_start_time)
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
splitmux->max_in_running_time = splitmux->fragment_start_time;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (!GST_CLOCK_STIME_IS_VALID (splitmux->max_in_running_time_dts))
splitmux->max_in_running_time_dts = running_time_dts;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (tc_meta) {
video_time_code_replace (&splitmux->fragment_start_tc, &tc_meta->tc);
splitmux->next_fragment_start_tc_time =
calculate_next_max_timecode (splitmux, &tc_meta->tc,
running_time, NULL);
splitmuxsink: Warn when calculating the next fragment time in timecode mode fails But only if timecode mode is enabled as it will fail all the time otherwise. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1557>
2022-01-24 08:45:33 +00:00
if (splitmux->tc_interval
&& !GST_CLOCK_TIME_IS_VALID (splitmux->next_fragment_start_tc_time))
{
GST_WARNING_OBJECT (splitmux,
"Couldn't calculate next fragment start time for timecode mode");
}
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
#ifndef GST_DISABLE_GST_DEBUG
{
gchar *tc_str;
tc_str = gst_video_time_code_to_string (&tc_meta->tc);
GST_DEBUG_OBJECT (splitmux,
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
"Initialize fragment start timecode %s, next fragment start timecode time %"
GST_TIME_FORMAT, tc_str,
GST_TIME_ARGS (splitmux->next_fragment_start_tc_time));
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
g_free (tc_str);
}
#endif
}
}
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
/* First check if we're at the very first GOP and the tracking was created
* from a GAP event. In that case don't start a new GOP on keyframes but
* just updated it as needed */
gop = g_queue_peek_tail (&splitmux->pending_input_gops);
if (!gop || (!gop->from_gap
&& !GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT))) {
gop = g_slice_new0 (InputGop);
gop->start_time = running_time;
gop->start_time_pts = running_time_pts;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
GST_LOG_OBJECT (splitmux,
"Next GOP start time now %" GST_STIME_FORMAT " (initial PTS %"
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GST_STIME_FORMAT ")", GST_STIME_ARGS (gop->start_time),
GST_STIME_ARGS (gop->start_time_pts));
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (tc_meta) {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
video_time_code_replace (&gop->start_tc, &tc_meta->tc);
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
#ifndef GST_DISABLE_GST_DEBUG
{
gchar *tc_str;
tc_str = gst_video_time_code_to_string (&tc_meta->tc);
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GST_DEBUG_OBJECT (splitmux, "Next GOP start timecode %s", tc_str);
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
g_free (tc_str);
}
#endif
}
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
g_queue_push_tail (&splitmux->pending_input_gops, gop);
} else {
gop->from_gap = FALSE;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (!GST_CLOCK_STIME_IS_VALID (gop->start_time)
|| gop->start_time > running_time) {
gop->start_time = running_time;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GST_LOG_OBJECT (splitmux,
"GOP start time updated now %" GST_STIME_FORMAT " (initial PTS %"
GST_STIME_FORMAT ")", GST_STIME_ARGS (gop->start_time),
GST_STIME_ARGS (gop->start_time_pts));
if (tc_meta) {
video_time_code_replace (&gop->start_tc, &tc_meta->tc);
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
#ifndef GST_DISABLE_GST_DEBUG
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
{
gchar *tc_str;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
tc_str = gst_video_time_code_to_string (&tc_meta->tc);
GST_DEBUG_OBJECT (splitmux, "Next GOP start timecode updated %s",
tc_str);
g_free (tc_str);
}
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
#endif
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
}
splitmuxsink: Enhancement for timecode based split The calculated threshold for timecode might be varying depending on "max-size-timecode" and framerate. For instance, with framerate 29.97 (30000/1001) and "max-size-timecode=00:02:00;02", every fragment will have identical number of frames 3598. However, when "max-size-timecode=00:02:00;00", calculated next keyframe via gst_video_time_code_add_interval() can be different per fragment, but this is the nature of timecode. To compensate such timecode drift, we should keep track of expected timecode of next fragment based on observed timecode.
2020-04-10 14:52:45 +00:00
}
}
splitmuxsink: Decouple keyframe request and the decision for fragmentation Split the decision for keyframe request and fragmentation in order to ensure periodic keyframe request.
2020-03-12 11:34:47 +00:00
/* Check whether we need to request next keyframe depending on
* current running time */
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (request_next_keyframe (splitmux, buf, running_time_dts) == FALSE) {
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_WARNING_OBJECT (splitmux,
"Could not request a keyframe. Files may not split at the exact location they should");
}
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
}
splitmuxsink: initialize mux_start_time properly mux_start_time refers to the running_time of the buffer that goes first in the output file. Normally this time is 0, so this variable is initialized to 0 during the state change to PAUSED. However, when dealing with dynamic pipelines and starting a recording while the pipeline has already run for a while, the running_time of the first buffer is > 0 and this causes a problem with detecting the end of the first file(s) when splitting by duration, because the code will later compare the threshold_time with (last buffer running_time - mux_start_time) and will get it wrong until mux_start_time advances enough to make this difference < threshold_time, creating empty files in the meantime. https://bugzilla.gnome.org/show_bug.cgi?id=753624
2015-07-22 15:45:12 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
{
InputGop *gop = g_queue_peek_tail (&splitmux->pending_input_gops);
if (gop) {
GST_DEBUG_OBJECT (pad, "Buf TS %" GST_STIME_FORMAT
" total GOP bytes %" G_GUINT64_FORMAT ", total next GOP bytes %"
G_GUINT64_FORMAT, GST_STIME_ARGS (buf_info->run_ts),
gop->total_bytes, gop->total_bytes);
}
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
loop_again = TRUE;
do {
if (ctx->flushing)
break;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
switch (splitmux->input_state) {
case SPLITMUX_INPUT_STATE_COLLECTING_GOP_START:
splitmuxsink: Avoid deadlock when releasing a pad from a running muxer Might not drain correctly Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/838>
2020-12-10 12:27:49 +00:00
if (ctx->is_releasing) {
/* The pad belonging to this context is being released */
GST_WARNING_OBJECT (pad, "Pad is being released while the muxer is "
"running. Data might not drain correctly");
loop_again = FALSE;
} else if (ctx->is_reference) {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
const InputGop *gop, *next_gop;
splitmux: Improve handling of repeated timestamps When handling input with timestamps that repeat, sometimes splitmuxsink would get confused and ignore a keyframe. The logic in question is a holdover from before the cmd queue moved the file cutting to the multiqueue output side and made it deterministic, so it's no longer needed on the input here. https://bugzilla.gnome.org/show_bug.cgi?id=796773
2018-07-16 14:03:19 +00:00
/* This is the reference context. If it's a keyframe,
* it marks the start of a new GOP and we should wait in
* check_completed_gop before continuing, but either way
* (keyframe or no, we'll pass this buffer through after
* so set loop_again to FALSE */
loop_again = FALSE;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
gop = g_queue_peek_head (&splitmux->pending_input_gops);
g_assert (gop != NULL);
next_gop = g_queue_peek_nth (&splitmux->pending_input_gops, 1);
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (ctx->in_running_time > splitmux->max_in_running_time)
splitmux->max_in_running_time = ctx->in_running_time;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
if (running_time_dts > splitmux->max_in_running_time_dts)
splitmux->max_in_running_time_dts = running_time_dts;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
GST_LOG_OBJECT (splitmux,
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
"Max in running time now %" GST_STIME_FORMAT ", DTS %"
GST_STIME_FORMAT, GST_STIME_ARGS (splitmux->max_in_running_time),
GST_STIME_ARGS (splitmux->max_in_running_time_dts));
if (!next_gop) {
GST_DEBUG_OBJECT (pad, "Waiting for end of GOP");
/* Allow other input pads to catch up to here too */
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
break;
}
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT)) {
GST_INFO_OBJECT (pad,
"Have keyframe with running time %" GST_STIME_FORMAT,
GST_STIME_ARGS (ctx->in_running_time));
keyframe = TRUE;
}
if (running_time_dts != GST_CLOCK_STIME_NONE
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
&& running_time_dts < next_gop->start_time_pts) {
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
GST_DEBUG_OBJECT (splitmux,
"Waiting until DTS (%" GST_STIME_FORMAT
") has passed next GOP start PTS (%" GST_STIME_FORMAT ")",
GST_STIME_ARGS (running_time_dts),
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
GST_STIME_ARGS (next_gop->start_time_pts));
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* Allow other input pads to catch up to here too */
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
}
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->input_state = SPLITMUX_INPUT_STATE_WAITING_GOP_COLLECT;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Wake up other input pads to collect this GOP */
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
check_completed_gop (splitmux, ctx);
} else {
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* Pass this buffer if the reference ctx is far enough ahead */
if (ctx->in_running_time < splitmux->max_in_running_time) {
loop_again = FALSE;
break;
}
splitmuxsink: allow non-video streams to serve as reference In the absence of a video stream, the first stream will be used as reference. https://bugzilla.gnome.org/show_bug.cgi?id=753617
2015-04-29 17:23:28 +00:00
/* We're still waiting for a keyframe on the reference pad, sleep */
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_LOG_OBJECT (pad, "Sleeping for GOP start");
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_WAIT_INPUT (splitmux);
GST_LOG_OBJECT (pad,
"Done sleeping for GOP start input state now %d",
splitmux->input_state);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
break;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
case SPLITMUX_INPUT_STATE_WAITING_GOP_COLLECT:{
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
/* We're collecting a GOP, this is only ever called for non-reference
* contexts as the reference context would be waiting inside
* check_completed_gop() */
g_assert (!ctx->is_reference);
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* If we overran the target timestamp, it might be time to process
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
* the GOP, otherwise bail out for more data. */
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_LOG_OBJECT (pad,
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
"Checking TS %" GST_STIME_FORMAT " against max %"
GST_STIME_FORMAT, GST_STIME_ARGS (ctx->in_running_time),
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
GST_STIME_ARGS (splitmux->max_in_running_time));
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
if (ctx->in_running_time < splitmux->max_in_running_time) {
loop_again = FALSE;
break;
}
GST_LOG_OBJECT (pad,
"Collected last packet of GOP. Checking other pads");
check_completed_gop (splitmux, ctx);
break;
splitmuxsink: Fix occasional deadlock when ending file with subtitle Deadlock occurs when splitting files if one stream received no buffer during the first GOP of the next file. That can happen in that scenario for example: 1) The first GOP of video is collected, it has a duration of 10s. max_in_running_time is set to 10s. 2) Other streams catchup and we receive the first subtitle buffer at ts=0 and has a duration of 1min. 3) We receive the 2nd subtitle buffer with a ts=1min. in_running_time is set to 1min. That buffer is blocked in handle_mq_input() because max_in_running_time is still 10s. 4) Since all in_running_time are now > 10s, max_out_running_time is now set to 10s. That first GOP gets recorded into the file. The muxer pop buffers out of the mq, when it tries to pop a 2nd subtitle buffer it blocks because the GstDataQueue is empty. 5) A 2nd GOP of video is collected and has a duration of 10s as well. max_in_running_time is now 20s. Since subtitle's in_running_time is already 1min, that GOP is already complete. 6) But let's say we overran the max file size, we thus set state to SPLITMUX_STATE_ENDING_FILE now. As soon as a buffer with ts > 10s (end of previous GOP) arrives in handle_mq_output(), EOS event is sent downstream instead. But since the subtitle queue is empty, that's never going to happen. Pipeline is now deadlocked. To fix this situation we have to: - Send a dummy event through the queue to wakeup output thread. - Update out_running_time to at least max_out_running_time so it sends EOS. - Respect time order, so we set out_running_tim=max_in_running_time because that's bigger than previous buffer and smaller than next. https://bugzilla.gnome.org/show_bug.cgi?id=763711
2016-03-18 19:45:01 +00:00
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
case SPLITMUX_INPUT_STATE_FINISHING_UP:
loop_again = FALSE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
default:
loop_again = FALSE;
break;
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
}
while (loop_again);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Only count keyframes for the reference context, consistently Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 09:53:12 +00:00
if (keyframe && ctx->is_reference)
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->queued_keyframes++;
splitmuxsink: Only count keyframes for the reference context, consistently Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 09:53:12 +00:00
buf_info->keyframe = keyframe;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
/* Update total input byte counter for overflow detect unless we're after
* EOS now */
splitmuxsink: Don't assert on the input side if no GOP is available when shutting down Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1119>
2021-10-12 16:01:37 +00:00
if (splitmux->input_state != SPLITMUX_INPUT_STATE_FINISHING_UP
&& splitmux->input_state != SPLITMUX_INPUT_STATE_STOPPED) {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
InputGop *gop = g_queue_peek_tail (&splitmux->pending_input_gops);
/* We must have a GOP at this point */
g_assert (gop != NULL);
gop->total_bytes += buf_info->buf_size;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
if (ctx->is_reference) {
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
gop->reference_bytes += buf_info->buf_size;
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
}
splitmuxsink: Never start a new fragment with no reference buffers If there has been no bytes from the reference stream muxed into the current fragment, then time can't have advanced, there's no GOP... this fragment would be broken or empty, so wait for some data on the reference buffer. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-09-17 12:56:01 +00:00
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Now add this buffer to the queue just before returning */
g_queue_push_head (&ctx->queued_bufs, buf_info);
GST_LOG_OBJECT (pad, "Returning to queue buffer %" GST_PTR_FORMAT
splitmuxsink: Handle negative running time Use signed clock times for running time everywhere so that we handle negative running times without going haywire, similar to what queue and multiqueue do these days.
2016-07-17 12:41:02 +00:00
" run ts %" GST_STIME_FORMAT, buf, GST_STIME_ARGS (ctx->in_running_time));
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_PAD_PROBE_INFO_FLOW_RETURN (info) = ret;
splitmux: fix memory leak If execution goes to the beach in line 981, buf_info goes out of scope without the memory being free'd. Handle this case. CID #1268403
2015-02-10 13:29:32 +00:00
return GST_PAD_PROBE_PASS;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: fix memory leak If execution goes to the beach in line 981, buf_info goes out of scope without the memory being free'd. Handle this case. CID #1268403
2015-02-10 13:29:32 +00:00
beach:
GST_SPLITMUX_UNLOCK (splitmux);
if (buf_info)
mq_stream_buf_free (buf_info);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
GST_PAD_PROBE_INFO_FLOW_RETURN (info) = ret;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
return GST_PAD_PROBE_PASS;
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
static void
grow_blocked_queues (GstSplitMuxSink * splitmux)
{
GList *cur;
/* Scan other queues for full-ness and grow them */
for (cur = g_list_first (splitmux->contexts);
cur != NULL; cur = g_list_next (cur)) {
MqStreamCtx *tmpctx = (MqStreamCtx *) (cur->data);
guint cur_limit;
guint cur_len = g_queue_get_length (&tmpctx->queued_bufs);
g_object_get (tmpctx->q, "max-size-buffers", &cur_limit, NULL);
GST_LOG_OBJECT (tmpctx->q, "Queue len %u", cur_len);
if (cur_len >= cur_limit) {
cur_limit = cur_len + 1;
GST_DEBUG_OBJECT (tmpctx->q,
"Queue overflowed and needs enlarging. Growing to %u buffers",
cur_limit);
g_object_set (tmpctx->q, "max-size-buffers", cur_limit, NULL);
}
}
}
static void
handle_q_underrun (GstElement * q, gpointer user_data)
{
MqStreamCtx *ctx = (MqStreamCtx *) (user_data);
GstSplitMuxSink *splitmux = ctx->splitmux;
GST_SPLITMUX_LOCK (splitmux);
GST_DEBUG_OBJECT (q,
"Queue reported underrun with %d keyframes and %d cmds enqueued",
splitmux->queued_keyframes, g_queue_get_length (&splitmux->out_cmd_q));
grow_blocked_queues (splitmux);
GST_SPLITMUX_UNLOCK (splitmux);
}
static void
handle_q_overrun (GstElement * q, gpointer user_data)
{
MqStreamCtx *ctx = (MqStreamCtx *) (user_data);
GstSplitMuxSink *splitmux = ctx->splitmux;
gboolean allow_grow = FALSE;
GST_SPLITMUX_LOCK (splitmux);
GST_DEBUG_OBJECT (q,
"Queue reported overrun with %d keyframes and %d cmds enqueued",
splitmux->queued_keyframes, g_queue_get_length (&splitmux->out_cmd_q));
if (splitmux->queued_keyframes < 2) {
/* Less than a full GOP queued, grow the queue */
allow_grow = TRUE;
} else if (g_queue_get_length (&splitmux->out_cmd_q) < 1) {
allow_grow = TRUE;
} else {
/* If another queue is starved, grow */
GList *cur;
for (cur = g_list_first (splitmux->contexts);
cur != NULL; cur = g_list_next (cur)) {
MqStreamCtx *tmpctx = (MqStreamCtx *) (cur->data);
if (tmpctx != ctx && g_queue_get_length (&tmpctx->queued_bufs) < 1) {
allow_grow = TRUE;
}
}
}
GST_SPLITMUX_UNLOCK (splitmux);
if (allow_grow) {
guint cur_limit;
g_object_get (q, "max-size-buffers", &cur_limit, NULL);
cur_limit++;
GST_DEBUG_OBJECT (q,
"Queue overflowed and needs enlarging. Growing to %u buffers",
cur_limit);
g_object_set (q, "max-size-buffers", cur_limit, NULL);
}
}
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
/* Called with SPLITMUX lock held */
static const gchar *
lookup_muxer_pad (GstSplitMuxSink * splitmux, const gchar * sinkpad_name)
{
const gchar *ret = NULL;
if (splitmux->muxerpad_map == NULL)
return NULL;
if (sinkpad_name == NULL) {
GST_WARNING_OBJECT (splitmux,
"Can't look up request pad in pad map without providing a pad name");
return NULL;
}
ret = gst_structure_get_string (splitmux->muxerpad_map, sinkpad_name);
if (ret) {
GST_INFO_OBJECT (splitmux, "Sink pad %s maps to muxer pad %s", sinkpad_name,
ret);
return g_strdup (ret);
}
return NULL;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static GstPad *
gst_splitmux_sink_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name, const GstCaps * caps)
{
GstSplitMuxSink *splitmux = (GstSplitMuxSink *) element;
GstPadTemplate *mux_template = NULL;
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
GstPad *ret = NULL, *muxpad = NULL;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GstElement *q;
GstPad *q_sink = NULL, *q_src = NULL;
splitmuxsink: Give internal queues useful names Makes debug output more useful
2019-05-28 23:20:07 +00:00
gchar *gname, *qname;
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
gboolean is_primary_video = FALSE, is_video = FALSE,
muxer_is_requestpad = FALSE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
MqStreamCtx *ctx;
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
const gchar *muxer_padname = NULL;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
GST_DEBUG_OBJECT (splitmux, "templ:%s, name:%s", templ->name_template, name);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (!create_muxer (splitmux))
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto fail;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
g_signal_emit (splitmux, signals[SIGNAL_MUXER_ADDED], 0, splitmux->muxer);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
if (g_str_equal (templ->name_template, "video") ||
g_str_has_prefix (templ->name_template, "video_aux_")) {
is_primary_video = g_str_equal (templ->name_template, "video");
if (is_primary_video && splitmux->have_video)
goto already_have_video;
is_video = TRUE;
}
/* See if there's a pad map and it lists this pad */
muxer_padname = lookup_muxer_pad (splitmux, name);
splitmuxsink: Only allow one video request pad The pacing of the overall muxing is controlled by the video GOPs arriving, so we can only handle 1 video stream, and the request pad is named accordingly. Ignore a request for a 2nd video pad if there's already an active one.
2016-10-26 03:32:48 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
if (muxer_padname == NULL) {
if (is_video) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* FIXME: Look for a pad template with matching caps, rather than by name */
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
GST_DEBUG_OBJECT (element,
"searching for pad-template with name 'video_%%u'");
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
mux_template =
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS
(splitmux->muxer), "video_%u");
splitmuxsink: pad request fails for flvmux splitmuxsink requests pad from element using pad template like "video_%u", "audio_%u" and "sink_%d". This is true for most of the muxers. But splitmuxsink not able to request pad to flvmux as flvmux has "audio" and "video" as pad templates. fix: splitmuxsink should fallback to "audio" and "video" when template not found. https://bugzilla.gnome.org/show_bug.cgi?id=774507
2016-11-16 05:23:51 +00:00
/* Fallback to find sink pad templates named 'video' (flvmux) */
if (!mux_template) {
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
GST_DEBUG_OBJECT (element,
"searching for pad-template with name 'video'");
splitmuxsink: pad request fails for flvmux splitmuxsink requests pad from element using pad template like "video_%u", "audio_%u" and "sink_%d". This is true for most of the muxers. But splitmuxsink not able to request pad to flvmux as flvmux has "audio" and "video" as pad templates. fix: splitmuxsink should fallback to "audio" and "video" when template not found. https://bugzilla.gnome.org/show_bug.cgi?id=774507
2016-11-16 05:23:51 +00:00
mux_template =
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS
(splitmux->muxer), "video");
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
name = NULL;
} else {
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
GST_DEBUG_OBJECT (element, "searching for pad-template with name '%s'",
templ->name_template);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
mux_template =
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS
(splitmux->muxer), templ->name_template);
splitmuxsink: pad request fails for flvmux splitmuxsink requests pad from element using pad template like "video_%u", "audio_%u" and "sink_%d". This is true for most of the muxers. But splitmuxsink not able to request pad to flvmux as flvmux has "audio" and "video" as pad templates. fix: splitmuxsink should fallback to "audio" and "video" when template not found. https://bugzilla.gnome.org/show_bug.cgi?id=774507
2016-11-16 05:23:51 +00:00
/* Fallback to find sink pad templates named 'audio' (flvmux) */
splitmuxsink: add the ability to mux auxilliary video streams The primary video stream is used to select fragment cut points at keyframe boundaries. Auxilliary video streams may be broken up at any packet - so fragments may not start with a keyframe for those streams.
2019-05-25 12:08:05 +00:00
if (!mux_template && g_str_has_prefix (templ->name_template, "audio_")) {
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
GST_DEBUG_OBJECT (element,
"searching for pad-template with name 'audio'");
splitmuxsink: pad request fails for flvmux splitmuxsink requests pad from element using pad template like "video_%u", "audio_%u" and "sink_%d". This is true for most of the muxers. But splitmuxsink not able to request pad to flvmux as flvmux has "audio" and "video" as pad templates. fix: splitmuxsink should fallback to "audio" and "video" when template not found. https://bugzilla.gnome.org/show_bug.cgi?id=774507
2016-11-16 05:23:51 +00:00
mux_template =
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS
(splitmux->muxer), "audio");
splitmuxsink: Don't use an explicit name for requesting audio pads ... unless the muxer uses the same audio pad template name as splitmuxsink. We can't request a pad called "audio_0" on a muxer that wants pads to be "sink_%d".
2017-04-20 12:16:24 +00:00
name = NULL;
splitmuxsink: pad request fails for flvmux splitmuxsink requests pad from element using pad template like "video_%u", "audio_%u" and "sink_%d". This is true for most of the muxers. But splitmuxsink not able to request pad to flvmux as flvmux has "audio" and "video" as pad templates. fix: splitmuxsink should fallback to "audio" and "video" when template not found. https://bugzilla.gnome.org/show_bug.cgi?id=774507
2016-11-16 05:23:51 +00:00
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
splitmuxsink: Support mpegtsmux as a muxer. As a fallback, look for a pad template sink_%d on the muxer when requesting pads, to support mpegtsmux https://bugzilla.gnome.org/show_bug.cgi?id=752999
2015-07-29 09:28:33 +00:00
if (mux_template == NULL) {
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
GST_DEBUG_OBJECT (element,
"searching for pad-template with name 'sink_%%d'");
splitmuxsink: Support mpegtsmux as a muxer. As a fallback, look for a pad template sink_%d on the muxer when requesting pads, to support mpegtsmux https://bugzilla.gnome.org/show_bug.cgi?id=752999
2015-07-29 09:28:33 +00:00
mux_template =
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS
(splitmux->muxer), "sink_%d");
splitmuxsink: Don't use an explicit name for requesting audio pads ... unless the muxer uses the same audio pad template name as splitmuxsink. We can't request a pad called "audio_0" on a muxer that wants pads to be "sink_%d".
2017-04-20 12:16:24 +00:00
name = NULL;
splitmuxsink: Support mpegtsmux as a muxer. As a fallback, look for a pad template sink_%d on the muxer when requesting pads, to support mpegtsmux https://bugzilla.gnome.org/show_bug.cgi?id=752999
2015-07-29 09:28:33 +00:00
}
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
if (mux_template == NULL) {
GST_DEBUG_OBJECT (element, "searching for pad-template with name 'sink'");
mux_template =
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS
(splitmux->muxer), "sink");
name = NULL;
}
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
if (mux_template == NULL) {
GST_ERROR_OBJECT (element,
"unable to find a suitable sink pad-template on the muxer");
goto fail;
}
GST_DEBUG_OBJECT (element, "found sink pad-template '%s' on the muxer",
mux_template->name_template);
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
if (mux_template->presence == GST_PAD_REQUEST) {
GST_DEBUG_OBJECT (element, "requesting pad from pad-template");
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
muxpad =
gst_element_request_pad (splitmux->muxer, mux_template, name, caps);
muxer_is_requestpad = TRUE;
} else if (mux_template->presence == GST_PAD_ALWAYS) {
GST_DEBUG_OBJECT (element, "accessing always pad from pad-template");
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
muxpad =
gst_element_get_static_pad (splitmux->muxer,
mux_template->name_template);
} else {
GST_ERROR_OBJECT (element,
"unexpected pad presence %d", mux_template->presence);
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
goto fail;
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
}
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
} else {
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
/* Have a muxer pad name */
if (!(muxpad = gst_element_get_static_pad (splitmux->muxer, muxer_padname))) {
if ((muxpad =
Use gst_element_request_pad_simple Instead of the deprecated gst_element_get_request_pad. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/958>
2021-04-20 20:08:23 +00:00
gst_element_request_pad_simple (splitmux->muxer, muxer_padname)))
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
muxer_is_requestpad = TRUE;
}
g_free ((gchar *) muxer_padname);
muxer_padname = NULL;
}
splitmuxsink: accept pads named 'sink' on the muxer, handle static pads as well https://bugzilla.gnome.org/show_bug.cgi?id=797241
2018-10-03 14:17:22 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
/* One way or another, we must have a muxer pad by now */
if (muxpad == NULL)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto fail;
splitmuxsink: add the ability to mux auxilliary video streams The primary video stream is used to select fragment cut points at keyframe boundaries. Auxilliary video streams may be broken up at any packet - so fragments may not start with a keyframe for those streams.
2019-05-25 12:08:05 +00:00
if (is_primary_video)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gname = g_strdup ("video");
else if (name == NULL)
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
gname = gst_pad_get_name (muxpad);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
else
gname = g_strdup (name);
splitmuxsink: Give internal queues useful names Makes debug output more useful
2019-05-28 23:20:07 +00:00
qname = g_strdup_printf ("queue_%s", gname);
if ((q = create_element (splitmux, "queue", qname, FALSE)) == NULL) {
g_free (qname);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto fail;
splitmuxsink: Give internal queues useful names Makes debug output more useful
2019-05-28 23:20:07 +00:00
}
g_free (qname);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
gst_element_set_state (q, GST_STATE_TARGET (splitmux));
g_object_set (q, "max-size-bytes", 0, "max-size-time", (guint64) (0),
"max-size-buffers", 5, NULL);
q_sink = gst_element_get_static_pad (q, "sink");
q_src = gst_element_get_static_pad (q, "src");
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
if (gst_pad_link (q_src, muxpad) != GST_PAD_LINK_OK) {
if (muxer_is_requestpad)
gst_element_release_request_pad (splitmux->muxer, muxpad);
gst_object_unref (GST_OBJECT (muxpad));
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto fail;
}
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
gst_object_unref (GST_OBJECT (muxpad));
splitmux: Add unit test for file splitting Add a unit test for file splitting, and fix the leaks in the splitmuxsink it found
2015-02-06 14:41:49 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
ctx = mq_stream_ctx_new (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
/* Context holds a ref: */
ctx->q = gst_object_ref (q);
ctx->srcpad = q_src;
ctx->sinkpad = q_sink;
ctx->q_overrun_id =
g_signal_connect (q, "overrun", (GCallback) handle_q_overrun, ctx);
g_signal_connect (q, "underrun", (GCallback) handle_q_underrun, ctx);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
ctx->src_pad_block_id =
splitmuxsink: Correctly catch FLUSH events in probes https://bugzilla.gnome.org/show_bug.cgi?id=767498
2017-04-20 10:17:35 +00:00
gst_pad_add_probe (q_src,
GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM | GST_PAD_PROBE_TYPE_EVENT_FLUSH,
splitmuxsink: Fix reference counting loop The stream context was holding a reference to the internal queue and pads, with pad probes that were in turn holding references to the stream context. This lead to a leak if the request pads weren't explicitly released. https://bugzilla.gnome.org/show_bug.cgi?id=796893
2018-08-14 16:10:25 +00:00
(GstPadProbeCallback) handle_mq_output, ctx, NULL);
splitmuxsink: add the ability to mux auxilliary video streams The primary video stream is used to select fragment cut points at keyframe boundaries. Auxilliary video streams may be broken up at any packet - so fragments may not start with a keyframe for those streams.
2019-05-25 12:08:05 +00:00
if (is_primary_video && splitmux->reference_ctx != NULL) {
splitmuxsink: allow non-video streams to serve as reference In the absence of a video stream, the first stream will be used as reference. https://bugzilla.gnome.org/show_bug.cgi?id=753617
2015-04-29 17:23:28 +00:00
splitmux->reference_ctx->is_reference = FALSE;
splitmux->reference_ctx = NULL;
}
if (splitmux->reference_ctx == NULL) {
splitmux->reference_ctx = ctx;
ctx->is_reference = TRUE;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
ret = gst_ghost_pad_new_from_template (gname, q_sink, templ);
g_object_set_qdata ((GObject *) (ret), PAD_CONTEXT, ctx);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
ctx->sink_pad_block_id =
splitmuxsink: Correctly catch FLUSH events in probes https://bugzilla.gnome.org/show_bug.cgi?id=767498
2017-04-20 10:17:35 +00:00
gst_pad_add_probe (q_sink,
splitmux: Drop allocation queries They can cause us to deadlock, while we're waiting for a new frame and upstream is waiting for the allocation query to be answered before sending a frame https://bugzilla.gnome.org/show_bug.cgi?id=783753
2017-06-13 14:40:19 +00:00
GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM | GST_PAD_PROBE_TYPE_EVENT_FLUSH |
GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM,
splitmuxsink: Fix reference counting loop The stream context was holding a reference to the internal queue and pads, with pad probes that were in turn holding references to the stream context. This lead to a leak if the request pads weren't explicitly released. https://bugzilla.gnome.org/show_bug.cgi?id=796893
2018-08-14 16:10:25 +00:00
(GstPadProbeCallback) handle_mq_input, ctx, NULL);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
GST_DEBUG_OBJECT (splitmux, "splitmuxsink pad %" GST_PTR_FORMAT
" feeds queue pad %" GST_PTR_FORMAT, ret, q_sink);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
splitmux->contexts = g_list_append (splitmux->contexts, ctx);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_free (gname);
splitmuxsink: add the ability to mux auxilliary video streams The primary video stream is used to select fragment cut points at keyframe boundaries. Auxilliary video streams may be broken up at any packet - so fragments may not start with a keyframe for those streams.
2019-05-25 12:08:05 +00:00
if (is_primary_video)
splitmuxsink: Only allow one video request pad The pacing of the overall muxing is controlled by the video GOPs arriving, so we can only handle 1 video stream, and the request pad is named accordingly. Ignore a request for a 2nd video pad if there's already an active one.
2016-10-26 03:32:48 +00:00
splitmux->have_video = TRUE;
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
gst_pad_set_active (ret, TRUE);
gst_element_add_pad (GST_ELEMENT (splitmux), ret);
splitmuxsink: Only allow one video request pad The pacing of the overall muxing is controlled by the video GOPs arriving, so we can only handle 1 video stream, and the request pad is named accordingly. Ignore a request for a 2nd video pad if there's already an active one.
2016-10-26 03:32:48 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmux: Add muxer-pad-map property Add a property which explicitly maps splitmuxsink pads to the muxer pads they should connect to, overriding the implicit logic that tries to match pads but yields arbitrary names.
2019-07-31 06:17:36 +00:00
return ret;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
fail:
GST_SPLITMUX_UNLOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (q_sink)
gst_object_unref (q_sink);
if (q_src)
gst_object_unref (q_src);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
return NULL;
splitmuxsink: Only allow one video request pad The pacing of the overall muxing is controlled by the video GOPs arriving, so we can only handle 1 video stream, and the request pad is named accordingly. Ignore a request for a 2nd video pad if there's already an active one.
2016-10-26 03:32:48 +00:00
already_have_video:
GST_DEBUG_OBJECT (splitmux, "video sink pad already requested");
GST_SPLITMUX_UNLOCK (splitmux);
return NULL;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
static void
gst_splitmux_sink_release_pad (GstElement * element, GstPad * pad)
{
GstSplitMuxSink *splitmux = (GstSplitMuxSink *) element;
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GstPad *muxpad = NULL;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
MqStreamCtx *ctx =
(MqStreamCtx *) (g_object_get_qdata ((GObject *) (pad), PAD_CONTEXT));
GST_SPLITMUX_LOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (splitmux->muxer == NULL)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto fail; /* Elements don't exist yet - nothing to release */
GST_INFO_OBJECT (pad, "releasing request pad");
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
muxpad = gst_pad_get_peer (ctx->srcpad);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Remove the context from our consideration */
splitmux->contexts = g_list_remove (splitmux->contexts, ctx);
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
if (ctx->sink_pad_block_id) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gst_pad_remove_probe (ctx->sinkpad, ctx->sink_pad_block_id);
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
gst_pad_send_event (ctx->sinkpad, gst_event_new_flush_start ());
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
if (ctx->src_pad_block_id)
gst_pad_remove_probe (ctx->srcpad, ctx->src_pad_block_id);
splitmuxsink: fix sink pad release while PLAYING - Release the split mux lock while removing the probes - Flush the sinkpad to unblock other pads - Turn check_completed_gop into a do while statement, when waking up we want to recheck whether the current GOP is ready for sending Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/719>
2020-09-08 18:57:33 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Avoid deadlock when releasing a pad from a running muxer Might not drain correctly Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/838>
2020-12-10 12:27:49 +00:00
ctx->is_releasing = TRUE;
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Can release the context now */
splitmuxsink: Fix reference counting loop The stream context was holding a reference to the internal queue and pads, with pad probes that were in turn holding references to the stream context. This lead to a leak if the request pads weren't explicitly released. https://bugzilla.gnome.org/show_bug.cgi?id=796893
2018-08-14 16:10:25 +00:00
mq_stream_ctx_free (ctx);
splitmuxsink: Take ownership of floating refs sink the floating ref when handed a muxer or sink to use so we clearly take ownership.
2016-10-26 00:59:32 +00:00
if (ctx == splitmux->reference_ctx)
splitmux->reference_ctx = NULL;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Release and free the muxer input */
splitmuxsink: Fix GObject warnings on shutdown. Commit 83e718 added a pad template to splitmux request pads, which means that GstElement now releases the pads on dispose, but after having removed all elements in the bin and unlinked them. Make sure we can handle cleanup in that case without throwing assertions. https://bugzilla.gnome.org/show_bug.cgi?id=773784
2016-11-02 00:00:13 +00:00
if (muxpad) {
gst_element_release_request_pad (splitmux->muxer, muxpad);
gst_object_unref (muxpad);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: Only allow one video request pad The pacing of the overall muxing is controlled by the video GOPs arriving, so we can only handle 1 video stream, and the request pad is named accordingly. Ignore a request for a 2nd video pad if there's already an active one.
2016-10-26 03:32:48 +00:00
if (GST_PAD_PAD_TEMPLATE (pad) &&
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
g_str_equal (GST_PAD_TEMPLATE_NAME_TEMPLATE (GST_PAD_PAD_TEMPLATE
(pad)), "video"))
splitmuxsink: Only allow one video request pad The pacing of the overall muxing is controlled by the video GOPs arriving, so we can only handle 1 video stream, and the request pad is named accordingly. Ignore a request for a 2nd video pad if there's already an active one.
2016-10-26 03:32:48 +00:00
splitmux->have_video = FALSE;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
gst_element_remove_pad (element, pad);
splitmuxsink: do not destroy the multiqueue & muxer when going to NULL Instead, delay it until all request pads have been released. This is because the release_pad() vfunc requires the multiqueue and muxer to be there in order to release their request pads as well. If those elements are destroyed earlier, release_pad() does not work, no pads are released and some resources are leaked. https://bugzilla.gnome.org/show_bug.cgi?id=753622
2015-10-24 21:57:29 +00:00
/* Reset the internal elements only after all request pads are released */
if (splitmux->contexts == NULL)
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
gst_splitmux_reset_elements (splitmux);
splitmuxsink: do not destroy the multiqueue & muxer when going to NULL Instead, delay it until all request pads have been released. This is because the release_pad() vfunc requires the multiqueue and muxer to be there in order to release their request pads as well. If those elements are destroyed earlier, release_pad() does not work, no pads are released and some resources are leaked. https://bugzilla.gnome.org/show_bug.cgi?id=753622
2015-10-24 21:57:29 +00:00
splitmuxsink: Avoid deadlock when releasing a pad from a running muxer Might not drain correctly Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/838>
2020-12-10 12:27:49 +00:00
/* Wake up other input streams to check if the completion conditions have
* changed */
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
fail:
GST_SPLITMUX_UNLOCK (splitmux);
}
static GstElement *
create_element (GstSplitMuxSink * splitmux,
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
const gchar * factory, const gchar * name, gboolean locked)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
{
GstElement *ret = gst_element_factory_make (factory, name);
if (ret == NULL) {
g_warning ("Failed to create %s - splitmuxsink will not work", name);
return NULL;
}
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
if (locked) {
/* Ensure the sink starts in locked state and NULL - it will be changed
* by the filename setting code */
gst_element_set_locked_state (ret, TRUE);
gst_element_set_state (ret, GST_STATE_NULL);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
if (!gst_bin_add (GST_BIN (splitmux), ret)) {
g_warning ("Could not add %s element - splitmuxsink will not work", name);
gst_object_unref (ret);
return NULL;
}
return ret;
}
static gboolean
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
create_muxer (GstSplitMuxSink * splitmux)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
{
/* Create internal elements */
if (splitmux->muxer == NULL) {
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GstElement *provided_muxer = NULL;
GST_OBJECT_LOCK (splitmux);
if (splitmux->provided_muxer != NULL)
provided_muxer = gst_object_ref (splitmux->provided_muxer);
GST_OBJECT_UNLOCK (splitmux);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if ((!splitmux->async_finalize && provided_muxer == NULL) ||
(splitmux->async_finalize && splitmux->muxer_factory == NULL)) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
if ((splitmux->muxer =
splitmuxsink: always use factory property when set Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1024>
2021-07-08 00:22:20 +00:00
create_element (splitmux,
splitmux->muxer_factory ? splitmux->
muxer_factory : DEFAULT_MUXER, "muxer", FALSE)) == NULL)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto fail;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
} else if (splitmux->async_finalize) {
if ((splitmux->muxer =
create_element (splitmux, splitmux->muxer_factory, "muxer",
FALSE)) == NULL)
goto fail;
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
if (splitmux->muxer_preset && GST_IS_PRESET (splitmux->muxer))
gst_preset_load_preset (GST_PRESET (splitmux->muxer),
splitmux->muxer_preset);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->muxer_properties)
gst_structure_foreach (splitmux->muxer_properties,
_set_property_from_structure, splitmux->muxer);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
} else {
splitmuxsink: Set child elements to NULL when removing. Make sure that elements are in the NULL state when removing. Fixes critical warnings when errors occur early on in starting up.
2016-10-25 03:51:52 +00:00
/* Ensure it's not in locked state (we might be reusing an old element) */
gst_element_set_locked_state (provided_muxer, FALSE);
splitmuxsink: do not access property variable without the object lock, use the local stack copy instead
2015-04-15 09:07:27 +00:00
if (!gst_bin_add (GST_BIN (splitmux), provided_muxer)) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_warning ("Could not add muxer element - splitmuxsink will not work");
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
gst_object_unref (provided_muxer);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
goto fail;
}
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
splitmux->muxer = provided_muxer;
gst_object_unref (provided_muxer);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Use muxer reserved space properties if present. If the use-robust-muxing property is set, check if the assigned muxer has reserved-max-duration and reserved-duration-remaining properties, and if so set the configured maximum duration to the reserved-max-duration property, and monitor the remaining space to start a new file if the reserved header space is about to run out - even though it never ought to.
2015-04-07 13:53:19 +00:00
if (splitmux->use_robust_muxing) {
update_muxer_properties (splitmux);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
return TRUE;
fail:
return FALSE;
}
static GstElement *
find_sink (GstElement * e)
{
GstElement *res = NULL;
GstIterator *iter;
gboolean done = FALSE;
GValue data = { 0, };
if (!GST_IS_BIN (e))
return e;
splitmuxsink: Return a bin with a "location" property as a sink Splitmuxsink might be called with a custom bin as a sink. If it has a "location" property, it can be used.
2016-12-22 15:34:08 +00:00
if (g_object_class_find_property (G_OBJECT_GET_CLASS (e), "location") != NULL)
return e;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
iter = gst_bin_iterate_sinks (GST_BIN (e));
while (!done) {
switch (gst_iterator_next (iter, &data)) {
case GST_ITERATOR_OK:
{
GstElement *child = g_value_get_object (&data);
if (g_object_class_find_property (G_OBJECT_GET_CLASS (child),
"location") != NULL) {
res = child;
done = TRUE;
}
g_value_reset (&data);
break;
}
case GST_ITERATOR_RESYNC:
gst_iterator_resync (iter);
break;
case GST_ITERATOR_DONE:
done = TRUE;
break;
case GST_ITERATOR_ERROR:
g_assert_not_reached ();
break;
}
}
g_value_unset (&data);
gst_iterator_free (iter);
return res;
}
static gboolean
create_sink (GstSplitMuxSink * splitmux)
{
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
GstElement *provided_sink = NULL;
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
if (splitmux->active_sink == NULL) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
GST_OBJECT_LOCK (splitmux);
if (splitmux->provided_sink != NULL)
provided_sink = gst_object_ref (splitmux->provided_sink);
GST_OBJECT_UNLOCK (splitmux);
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if ((!splitmux->async_finalize && provided_sink == NULL) ||
(splitmux->async_finalize && splitmux->sink_factory == NULL)) {
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
if ((splitmux->sink =
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
create_element (splitmux, DEFAULT_SINK, "sink", TRUE)) == NULL)
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
goto fail;
splitmux->active_sink = splitmux->sink;
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
} else if (splitmux->async_finalize) {
if ((splitmux->sink =
create_element (splitmux, splitmux->sink_factory, "sink",
TRUE)) == NULL)
goto fail;
splitmuxsink: Add new properties for setting muxer/sink presets Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/644>
2020-06-25 09:58:48 +00:00
if (splitmux->sink_preset && GST_IS_PRESET (splitmux->sink))
gst_preset_load_preset (GST_PRESET (splitmux->sink),
splitmux->sink_preset);
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
if (splitmux->sink_properties)
gst_structure_foreach (splitmux->sink_properties,
_set_property_from_structure, splitmux->sink);
splitmux->active_sink = splitmux->sink;
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
} else {
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
/* Ensure the sink starts in locked state and NULL - it will be changed
* by the filename setting code */
gst_element_set_locked_state (provided_sink, TRUE);
gst_element_set_state (provided_sink, GST_STATE_NULL);
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
if (!gst_bin_add (GST_BIN (splitmux), provided_sink)) {
g_warning ("Could not add sink elements - splitmuxsink will not work");
gst_object_unref (provided_sink);
goto fail;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
splitmux->active_sink = provided_sink;
splitmuxsink: Protect property variables with the object lock. Use the object lock instead of the splitmux lock to protect internal property variables, so they're not locked when switching to a new file. https://bugzilla.gnome.org/show_bug.cgi?id=744420
2015-03-06 13:55:47 +00:00
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
/* The bin holds a ref now, we can drop our tmp ref */
gst_object_unref (provided_sink);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
/* Find the sink element */
splitmux->sink = find_sink (splitmux->active_sink);
if (splitmux->sink == NULL) {
g_warning
("Could not locate sink element in provided sink - splitmuxsink will not work");
goto fail;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
#if 1
if (g_object_class_find_property (G_OBJECT_GET_CLASS (splitmux->sink),
"async") != NULL) {
/* async child elements are causing state change races and weird
* failures, so let's try and turn that off */
g_object_set (splitmux->sink, "async", FALSE, NULL);
}
#endif
splitmuxsink: only try to create internal sink if it doesn't exist This allows splitmuxsink to be reused after being put to NULL. Test included https://bugzilla.gnome.org/show_bug.cgi?id=762893
2016-03-01 02:40:03 +00:00
if (!gst_element_link (splitmux->muxer, splitmux->active_sink)) {
g_warning ("Failed to link muxer and sink- splitmuxsink will not work");
goto fail;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
return TRUE;
fail:
return FALSE;
}
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
#endif
static void
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
set_next_filename (GstSplitMuxSink * splitmux, MqStreamCtx * ctx)
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
{
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
gchar *fname = NULL;
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
GstSample *sample;
GstCaps *caps;
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
gst_splitmux_sink_ensure_max_files (splitmux);
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
if (ctx->cur_out_buffer == NULL) {
GST_WARNING_OBJECT (splitmux, "Starting next file without buffer");
}
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
caps = gst_pad_get_current_caps (ctx->srcpad);
splitmuxsink: Add option for timecode-based split If this option is given, it will calculate the next split point based on timecode difference. https://bugzilla.gnome.org/show_bug.cgi?id=774209
2016-12-22 15:40:40 +00:00
sample = gst_sample_new (ctx->cur_out_buffer, caps, &ctx->out_segment, NULL);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
g_signal_emit (splitmux, signals[SIGNAL_FORMAT_LOCATION_FULL], 0,
splitmux->fragment_id, sample, &fname);
gst_sample_unref (sample);
if (caps)
gst_caps_unref (caps);
if (fname == NULL) {
/* Fallback to the old signal if the new one returned nothing */
g_signal_emit (splitmux, signals[SIGNAL_FORMAT_LOCATION], 0,
splitmux->fragment_id, &fname);
}
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
if (!fname)
fname = splitmux->location ?
g_strdup_printf (splitmux->location, splitmux->fragment_id) : NULL;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
splitmuxsink: add a "format-location" signal that allows better control over filenames In certain applications, splitting into files named after a base location template and an incremental sequence number is not enough. This signal gives more fine-grained control to the application to decide how to name the files. https://bugzilla.gnome.org/show_bug.cgi?id=750106
2015-04-15 16:27:04 +00:00
if (fname) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_INFO_OBJECT (splitmux, "Setting file to %s", fname);
splitmuxsink: add fakesink support fakesink does not support "location" property and was generating a warning.
2019-11-07 11:28:58 +00:00
if (g_object_class_find_property (G_OBJECT_GET_CLASS (splitmux->sink),
"location") != NULL)
g_object_set (splitmux->sink, "location", fname, NULL);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
g_free (fname);
}
splitmuxsink: Increment fragment_id even if no fragment location was provided Applications might handle locations and generally configuration of the sink by themselves instead of having splitmuxsink set the location on the sink. Nonetheless it makes sense to increment the fragment_id that is passed to the signal so that applications know which fragment is requested.
2019-12-12 16:53:00 +00:00
splitmux->fragment_id++;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Don't take lock during posting message An application might try to access splitmuxsink from sync message handler by g_object_{get,set} which takes lock also. In general, we don't take lock around message handler.
2019-10-07 03:45:00 +00:00
/* called with GST_SPLITMUX_LOCK */
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
static void
do_async_start (GstSplitMuxSink * splitmux)
{
GstMessage *message;
if (!splitmux->need_async_start) {
GST_INFO_OBJECT (splitmux, "no async_start needed");
return;
}
splitmux->async_pending = TRUE;
GST_INFO_OBJECT (splitmux, "Sending async_start message");
message = gst_message_new_async_start (GST_OBJECT_CAST (splitmux));
splitmuxsink: Don't take lock during posting message An application might try to access splitmuxsink from sync message handler by g_object_{get,set} which takes lock also. In general, we don't take lock around message handler.
2019-10-07 03:45:00 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
GST_BIN_CLASS (parent_class)->handle_message (GST_BIN_CAST
(splitmux), message);
splitmuxsink: Don't take lock during posting message An application might try to access splitmuxsink from sync message handler by g_object_{get,set} which takes lock also. In general, we don't take lock around message handler.
2019-10-07 03:45:00 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
}
splitmuxsink: Don't take lock during posting message An application might try to access splitmuxsink from sync message handler by g_object_{get,set} which takes lock also. In general, we don't take lock around message handler.
2019-10-07 03:45:00 +00:00
/* called with GST_SPLITMUX_LOCK */
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
static void
do_async_done (GstSplitMuxSink * splitmux)
{
GstMessage *message;
if (splitmux->async_pending) {
GST_INFO_OBJECT (splitmux, "Sending async_done message");
splitmuxsink: Don't take lock during posting message An application might try to access splitmuxsink from sync message handler by g_object_{get,set} which takes lock also. In general, we don't take lock around message handler.
2019-10-07 03:45:00 +00:00
splitmux->async_pending = FALSE;
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
message =
gst_message_new_async_done (GST_OBJECT_CAST (splitmux),
GST_CLOCK_TIME_NONE);
GST_BIN_CLASS (parent_class)->handle_message (GST_BIN_CAST
(splitmux), message);
splitmuxsink: Don't take lock during posting message An application might try to access splitmuxsink from sync message handler by g_object_{get,set} which takes lock also. In general, we don't take lock around message handler.
2019-10-07 03:45:00 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
}
splitmux->need_async_start = FALSE;
}
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
static void
gst_splitmux_sink_reset (GstSplitMuxSink * splitmux)
{
splitmux->max_in_running_time = GST_CLOCK_STIME_NONE;
splitmuxsink: Keep track of the pending input GOPs in a queue This cleans up input GOP handling and makes it possible to handle more than 2 pending GOPs, which could happen before if keyframes are arriving with too short of a distance between them. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-21 10:37:35 +00:00
splitmux->max_in_running_time_dts = GST_CLOCK_STIME_NONE;
splitmux->fragment_start_time = GST_CLOCK_STIME_NONE;
splitmux->fragment_start_time_pts = GST_CLOCK_STIME_NONE;
g_clear_pointer (&splitmux->fragment_start_tc, gst_video_time_code_free);
g_queue_foreach (&splitmux->pending_input_gops, (GFunc) input_gop_free, NULL);
g_queue_clear (&splitmux->pending_input_gops);
splitmuxsink: Handle frame reordering due to B frames better Instead of assuming that the PTS of a keyframe is the lowest PTS of a GOP, wait until the DTS has passed this PTS and take the minimum PTS up to that point. That way the minimum PTS of a GOP can be determined, at least for closed GOP streams. Open GOP streams still can't be handled properly. By knowing the minimum PTS of each GOP, keyframes can be requested at the correct time relative to the GOP (and thus fragment) start and fragment overflow calculations can calculate the correct durations of the GOPs. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 16:36:27 +00:00
splitmuxsink: Use GST_CLOCK_STIME_NONE instead of 0 to initialize max out running time Otherwise streams with only DTS would misbehave while it is negative. For outputting everything immediately at EOS, use G_MAXINT64 instead which is bigger-or-equal to any other running time. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1005>
2021-09-16 10:11:20 +00:00
splitmux->max_out_running_time = GST_CLOCK_STIME_NONE;
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
splitmux->fragment_total_bytes = 0;
splitmuxsink: Never start a new fragment with no reference buffers If there has been no bytes from the reference stream muxed into the current fragment, then time can't have advanced, there's no GOP... this fragment would be broken or empty, so wait for some data on the reference buffer. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-09-17 12:56:01 +00:00
splitmux->fragment_reference_bytes = 0;
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
splitmux->muxed_out_bytes = 0;
splitmux->ready_for_output = FALSE;
g_atomic_int_set (&(splitmux->split_requested), FALSE);
g_atomic_int_set (&(splitmux->do_split_next_gop), FALSE);
splitmuxsink: Don't send too many force key unit event splitmuxsink should requst keyframe depending on configured threshold and previously requested time in order to avoid too many keyframe request.
2020-04-03 04:45:56 +00:00
splitmux->next_fku_time = GST_CLOCK_TIME_NONE;
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
gst_queue_array_clear (splitmux->times_to_split);
g_list_foreach (splitmux->contexts, (GFunc) mq_stream_ctx_reset, NULL);
splitmux->queued_keyframes = 0;
g_queue_foreach (&splitmux->out_cmd_q, (GFunc) out_cmd_buf_free, NULL);
g_queue_clear (&splitmux->out_cmd_q);
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
static GstStateChangeReturn
gst_splitmux_sink_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret;
GstSplitMuxSink *splitmux = (GstSplitMuxSink *) element;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:{
GST_SPLITMUX_LOCK (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
if (!create_muxer (splitmux) || !create_sink (splitmux)) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
ret = GST_STATE_CHANGE_FAILURE;
GST_SPLITMUX_UNLOCK (splitmux);
goto beach;
}
splitmuxsink: Added new async-finalize mode This mode is useful for muxers that can take a long time to finalize a file. Instead of blocking the whole upstream pipeline while the muxer is doing its stuff, we can unlink it and spawn a new muxer+sink combination to continue running normally. This requires us to receive the muxer and sink (if needed) as factories, optionally accompanied by their respective properties structures. Also added the muxer-added and sink-added signals, in case custom code has to be called for them. https://bugzilla.gnome.org/show_bug.cgi?id=783754
2017-06-13 14:42:55 +00:00
g_signal_emit (splitmux, signals[SIGNAL_MUXER_ADDED], 0, splitmux->muxer);
g_signal_emit (splitmux, signals[SIGNAL_SINK_ADDED], 0, splitmux->sink);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: provides a start-index property Allow to change the fragment-id start index.
2019-12-05 14:58:40 +00:00
splitmux->fragment_id = splitmux->start_index;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
}
case GST_STATE_CHANGE_READY_TO_PAUSED:{
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
/* Make sure contexts and tracking times are cleared, in case we're being reused */
gst_splitmux_sink_reset (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Start by collecting one input on each pad */
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->input_state = SPLITMUX_INPUT_STATE_COLLECTING_GOP_START;
splitmux->output_state = SPLITMUX_OUTPUT_STATE_START_NEXT_FILE;
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
GST_SPLITMUX_STATE_LOCK (splitmux);
splitmux->shutdown = FALSE;
GST_SPLITMUX_STATE_UNLOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
break;
}
case GST_STATE_CHANGE_PAUSED_TO_READY:
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
case GST_STATE_CHANGE_READY_TO_READY:
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
g_atomic_int_set (&(splitmux->split_requested), FALSE);
g_atomic_int_set (&(splitmux->do_split_next_gop), FALSE);
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
/* Fall through */
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
case GST_STATE_CHANGE_READY_TO_NULL:
splitmuxsink: Don't use the element state lock Using the element state lock to avoid splitmuxsink shutting down while doing element manipulations can lead to a deadlock on shutdown if a fragment switch happens at exactly the wrong moment. Use a private mutex and a shutdown boolean instead. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/798>
2020-10-30 15:19:07 +00:00
GST_SPLITMUX_STATE_LOCK (splitmux);
splitmux->shutdown = TRUE;
GST_SPLITMUX_STATE_UNLOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_LOCK (splitmux);
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
gst_splitmux_sink_reset (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
splitmux->output_state = SPLITMUX_OUTPUT_STATE_STOPPED;
splitmux->input_state = SPLITMUX_INPUT_STATE_STOPPED;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Wake up any blocked threads */
GST_LOG_OBJECT (splitmux,
"State change -> NULL or READY. Waking threads");
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_BROADCAST_INPUT (splitmux);
GST_SPLITMUX_BROADCAST_OUTPUT (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
goto beach;
switch (transition) {
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
splitmux->need_async_start = TRUE;
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:{
/* Change state async, because our child sink might not
* be ready to do that for us yet if it's state is still locked */
splitmux->need_async_start = TRUE;
/* we want to go async to PAUSED until we managed to configure and add the
* sink */
GST_SPLITMUX_LOCK (splitmux);
do_async_start (splitmux);
GST_SPLITMUX_UNLOCK (splitmux);
ret = GST_STATE_CHANGE_ASYNC;
break;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
case GST_STATE_CHANGE_READY_TO_NULL:
GST_SPLITMUX_LOCK (splitmux);
splitmux->fragment_id = 0;
splitmuxsink: do not destroy the multiqueue & muxer when going to NULL Instead, delay it until all request pads have been released. This is because the release_pad() vfunc requires the multiqueue and muxer to be there in order to release their request pads as well. If those elements are destroyed earlier, release_pad() does not work, no pads are released and some resources are leaked. https://bugzilla.gnome.org/show_bug.cgi?id=753622
2015-10-24 21:57:29 +00:00
/* Reset internal elements only if no pad contexts are using them */
if (splitmux->contexts == NULL)
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
gst_splitmux_reset_elements (splitmux);
splitmuxsink: Add format-location-full signal Add a new signal for formatting the filename, which receives a GstSample containing the first buffer from the reference stream that will be muxed into that file. Useful for creating filenames that are based on the running time or other attributes of the buffer. To make it work, opening of files and setting filenames is now deferred until there is some data to write to it, which also requires some changes to how async state changes and gap events are handled.
2016-11-17 12:40:27 +00:00
do_async_done (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
GST_SPLITMUX_UNLOCK (splitmux);
break;
default:
break;
}
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
return ret;
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
beach:
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
if (transition == GST_STATE_CHANGE_NULL_TO_READY) {
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
/* Cleanup elements on failed transition out of NULL */
splitmuxsink: Reset cleanly for reuse Reset the splitmuxsink completely when changing states so that it can be reused. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/1241
2020-03-19 12:05:49 +00:00
gst_splitmux_reset_elements (splitmux);
splitmux: Rewrite buffer collection and scheduling Majorly change the way that splitmuxsink collects incoming data and sends it to the output, so that it makes all decisions about when / where to split files on the input side. Use separate queues for each stream, so they can be grown individually and kept as small as possible. This removes raciness I observed where sometimes some data would end up put in a different output file over multiple runs with the same input. Also fixes hangs with input queues getting full and causing muxing to stall out.
2016-11-18 11:42:18 +00:00
GST_SPLITMUX_LOCK (splitmux);
do_async_done (splitmux);
GST_SPLITMUX_UNLOCK (splitmux);
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
}
splitmuxsink: Prevent hang going back to NULL after failures Prevent a condition where splitmuxsink won't go back to NULL state after a child element fails to change state by making sure that a READY->READY state change doesn't fail, and by returning GST_FLOW_ERROR or GST_FLOW_FLUSHING upstream to shut down streaming as quickly as possible. This can happen after (for example) setting an invalid filename on the sink element. In that case, the READY->PAUSED transition fails, but with internal elements still in the NULL state. Trying to set splitmuxsink back to NULL then ends up trying to bring those NULL elements up to READY with a READY->READY transition, (which fails, prevent splitmuxsink from getting to NULL) Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/1023>
2021-07-07 14:12:52 +00:00
if (transition == GST_STATE_CHANGE_READY_TO_READY) {
/* READY to READY transition only happens when we're already
* in READY state, but a child element is in NULL, which
* happens when there's an error changing the state of the sink.
* We need to make sure not to fail the state transition, or
* the core won't transition us back to NULL successfully */
ret = GST_STATE_CHANGE_SUCCESS;
}
splitmux: Implement new elements for splitting files at mux level. Implement 2 new elements - splitmuxsink and splitmuxsrc. splitmuxsink is a bin which wraps a muxer and takes 1 video stream, plus audio/subtitle streams, and starts a new file whenever necessary to avoid overrunning a threshold of either bytes or time. New files are started at a keyframe, and corresponding audio and subtitle streams are split at packet boundaries to match video GOP timestamps. splitmuxsrc is a corresponding source element which handles the splitmux:// URL and plays back all component files, reconstructing the original elementary streams as it goes.
2014-07-31 14:07:53 +00:00
return ret;
}
splitmuxsink: Add max_files_number property https://bugzilla.gnome.org/show_bug.cgi?id=744612
2016-04-13 17:45:07 +00:00
static void
gst_splitmux_sink_ensure_max_files (GstSplitMuxSink * splitmux)
{
if (splitmux->max_files && splitmux->fragment_id >= splitmux->max_files) {
splitmux->fragment_id = 0;
}
}
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
static void
split_now (GstSplitMuxSink * splitmux)
{
splitmuxsink: Implement split-after The behaviour of split-now is to output the current GOP after starting a new file. The newly-added split-after signal will output the current GOP to the old file if possible once a new GOP is opened. https://bugzilla.gnome.org/show_bug.cgi?id=796982
2018-08-16 19:42:37 +00:00
g_atomic_int_set (&(splitmux->do_split_next_gop), TRUE);
}
static void
split_after (GstSplitMuxSink * splitmux)
{
g_atomic_int_set (&(splitmux->split_requested), TRUE);
splitmuxsink: added a "split now" action signal Now, the video file can be split at an arbitrary time chosen by the user. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2017-09-21 15:23:54 +00:00
}
splitmuxsink: Added a split-at-running-time action signal The video file can now be split at an arbitrary time, given by the user as an argument to the action signal. https://bugzilla.gnome.org/show_bug.cgi?id=787922
2018-09-26 14:43:05 +00:00
static void
split_at_running_time (GstSplitMuxSink * splitmux, GstClockTime split_time)
{
gboolean send_keyframe_requests;
GST_SPLITMUX_LOCK (splitmux);
gst_queue_array_push_tail_struct (splitmux->times_to_split, &split_time);
send_keyframe_requests = splitmux->send_keyframe_requests;
GST_SPLITMUX_UNLOCK (splitmux);
if (send_keyframe_requests) {
GstEvent *ev =
gst_video_event_new_upstream_force_key_unit (split_time, TRUE, 0);
GST_INFO_OBJECT (splitmux, "Requesting next keyframe at %" GST_TIME_FORMAT,
GST_TIME_ARGS (split_time));
if (!gst_pad_push_event (splitmux->reference_ctx->sinkpad, ev)) {
GST_WARNING_OBJECT (splitmux,
"Could not request keyframe at %" GST_TIME_FORMAT,
GST_TIME_ARGS (split_time));
}
}
}
Reference in a new issue Copy permalink