mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-16 13:26:36 +00:00
640a65bf96
volatile is not sufficient to provide atomic guarantees and real atomics should be used instead. GCC 11 has started warning about using volatile with atomic operations. https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1719 Discovered in https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/issues/868 Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/merge_requests/2098>
2489 lines
79 KiB
C
2489 lines
79 KiB
C
/* GStreamer
|
|
* Copyright (C) <2017> Carlos Rafael Giani <dv at pseudoterminal dot org>
|
|
*
|
|
* 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:gstnonstreamaudiodecoder
|
|
* @short_description: Base class for decoding of non-streaming audio
|
|
* @see_also: #GstAudioDecoder
|
|
*
|
|
* This base class is for decoders which do not operate on a streaming model.
|
|
* That is: they load the encoded media at once, as part of an initialization,
|
|
* and afterwards can decode samples (sometimes referred to as "rendering the
|
|
* samples").
|
|
*
|
|
* This sets it apart from GstAudioDecoder, which is a base class for
|
|
* streaming audio decoders.
|
|
*
|
|
* The base class is conceptually a mix between decoder and parser. This is
|
|
* unavoidable, since virtually no format that isn't streaming based has a
|
|
* clear distinction between parsing and decoding. As a result, this class
|
|
* also handles seeking.
|
|
*
|
|
* Non-streaming audio formats tend to have some characteristics unknown to
|
|
* more "regular" bitstreams. These include subsongs and looping.
|
|
*
|
|
* Subsongs are a set of songs-within-a-song. An analogy would be a multitrack
|
|
* recording, where each track is its own song. The first subsong is typically
|
|
* the "main" one. Subsongs were popular for video games to enable context-
|
|
* aware music; for example, subsong `#0` would be the "main" song, `#1` would be
|
|
* an alternate song playing when a fight started, `#2` would be heard during
|
|
* conversations etc. The base class is designed to always have at least one
|
|
* subsong. If the subclass doesn't provide any, the base class creates a
|
|
* "pseudo" subsong, which is actually the whole song.
|
|
* Downstream is informed about the subsong using a table of contents (TOC),
|
|
* but only if there are at least 2 subsongs.
|
|
*
|
|
* Looping refers to jumps within the song, typically backwards to the loop
|
|
* start (although bi-directional looping is possible). The loop is defined
|
|
* by a chronological start and end; once the playback position reaches the
|
|
* loop end, it jumps back to the loop start.
|
|
* Depending on the subclass, looping may not be possible at all, or it
|
|
* may only be possible to enable/disable it (that is, either no looping, or
|
|
* an infinite amount of loops), or it may allow for defining a finite number
|
|
* of times the loop is repeated.
|
|
* Looping can affect output in two ways. Either, the playback position is
|
|
* reset to the start of the loop, similar to what happens after a seek event.
|
|
* Or, it is not reset, so the pipeline sees playback steadily moving forwards,
|
|
* the playback position monotonically increasing. However, seeking must
|
|
* always happen within the confines of the defined subsong duration; for
|
|
* example, if a subsong is 2 minutes long, steady playback is at 5 minutes
|
|
* (because infinite looping is enabled), then seeking will still place the
|
|
* position within the 2 minute period.
|
|
* Loop count 0 means no looping. Loop count -1 means infinite looping.
|
|
* Nonzero positive values indicate how often a loop shall occur.
|
|
*
|
|
* If the initial subsong and loop count are set to values the subclass does
|
|
* not support, the subclass has a chance to correct these values.
|
|
* @get_property then reports the corrected versions.
|
|
*
|
|
* The base class operates as follows:
|
|
* * Unloaded mode
|
|
* - Initial values are set. If a current subsong has already been
|
|
* defined (for example over the command line with gst-launch), then
|
|
* the subsong index is copied over to current_subsong .
|
|
* Same goes for the num-loops and output-mode properties.
|
|
* Media is NOT loaded yet.
|
|
* - Once the sinkpad is activated, the process continues. The sinkpad is
|
|
* activated in push mode, and the class accumulates the incoming media
|
|
* data in an adapter inside the sinkpad's chain function until either an
|
|
* EOS event is received from upstream, or the number of bytes reported
|
|
* by upstream is reached. Then it loads the media, and starts the decoder
|
|
* output task.
|
|
* - If upstream cannot respond to the size query (in bytes) of @load_from_buffer
|
|
* fails, an error is reported, and the pipeline stops.
|
|
* - If there are no errors, @load_from_buffer is called to load the media. The
|
|
* subclass must at least call gst_nonstream_audio_decoder_set_output_format()
|
|
* there, and is free to make use of the initial subsong, output mode, and
|
|
* position. If the actual output mode or position differs from the initial
|
|
* value,it must set the initial value to the actual one (for example, if
|
|
* the actual starting position is always 0, set *initial_position to 0).
|
|
* If loading is unsuccessful, an error is reported, and the pipeline
|
|
* stops. Otherwise, the base class calls @get_current_subsong to retrieve
|
|
* the actual current subsong, @get_subsong_duration to report the current
|
|
* subsong's duration in a duration event and message, and @get_subsong_tags
|
|
* to send tags downstream in an event (these functions are optional; if
|
|
* set to NULL, the associated operation is skipped). Afterwards, the base
|
|
* class switches to loaded mode, and starts the decoder output task.
|
|
*
|
|
* * Loaded mode</title>
|
|
* - Inside the decoder output task, the base class repeatedly calls @decode,
|
|
* which returns a buffer with decoded, ready-to-play samples. If the
|
|
* subclass reached the end of playback, @decode returns FALSE, otherwise
|
|
* TRUE.
|
|
* - Upon reaching a loop end, subclass either ignores that, or loops back
|
|
* to the beginning of the loop. In the latter case, if the output mode is set
|
|
* to LOOPING, the subclass must call gst_nonstream_audio_decoder_handle_loop()
|
|
* *after* the playback position moved to the start of the loop. In
|
|
* STEADY mode, the subclass must *not* call this function.
|
|
* Since many decoders only provide a callback for when the looping occurs,
|
|
* and that looping occurs inside the decoding operation itself, the following
|
|
* mechanism for subclass is suggested: set a flag inside such a callback.
|
|
* Then, in the next @decode call, before doing the decoding, check this flag.
|
|
* If it is set, gst_nonstream_audio_decoder_handle_loop() is called, and the
|
|
* flag is cleared.
|
|
* (This function call is necessary in LOOPING mode because it updates the
|
|
* current segment and makes sure the next buffer that is sent downstream
|
|
* has its DISCONT flag set.)
|
|
* - When the current subsong is switched, @set_current_subsong is called.
|
|
* If it fails, a warning is reported, and nothing else is done. Otherwise,
|
|
* it calls @get_subsong_duration to get the new current subsongs's
|
|
* duration, @get_subsong_tags to get its tags, reports a new duration
|
|
* (i.e. it sends a duration event downstream and generates a duration
|
|
* message), updates the current segment, and sends the subsong's tags in
|
|
* an event downstream. (If @set_current_subsong has been set to NULL by
|
|
* the subclass, attempts to set a current subsong are ignored; likewise,
|
|
* if @get_subsong_duration is NULL, no duration is reported, and if
|
|
* @get_subsong_tags is NULL, no tags are sent downstream.)
|
|
* - When an attempt is made to switch the output mode, it is checked against
|
|
* the bitmask returned by @get_supported_output_modes. If the proposed
|
|
* new output mode is supported, the current segment is updated
|
|
* (it is open-ended in STEADY mode, and covers the (sub)song length in
|
|
* LOOPING mode), and the subclass' @set_output_mode function is called
|
|
* unless it is set to NULL. Subclasses should reset internal loop counters
|
|
* in this function.
|
|
*
|
|
* The relationship between (sub)song duration, output mode, and number of loops
|
|
* is defined this way (this is all done by the base class automatically):
|
|
*
|
|
* * Segments have their duration and stop values set to GST_CLOCK_TIME_NONE in
|
|
* STEADY mode, and to the duration of the (sub)song in LOOPING mode.
|
|
*
|
|
* * The duration that is returned to a DURATION query is always the duration
|
|
* of the (sub)song, regardless of number of loops or output mode. The same
|
|
* goes for DURATION messages and tags.
|
|
*
|
|
* * If the number of loops is >0 or -1, durations of TOC entries are set to
|
|
* the duration of the respective subsong in LOOPING mode and to G_MAXINT64 in
|
|
* STEADY mode. If the number of loops is 0, entry durations are set to the
|
|
* subsong duration regardless of the output mode.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <gst/gst.h>
|
|
#include <gst/audio/audio.h>
|
|
|
|
#include "gstnonstreamaudiodecoder.h"
|
|
|
|
|
|
GST_DEBUG_CATEGORY (nonstream_audiodecoder_debug);
|
|
#define GST_CAT_DEFAULT nonstream_audiodecoder_debug
|
|
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_CURRENT_SUBSONG,
|
|
PROP_SUBSONG_MODE,
|
|
PROP_NUM_LOOPS,
|
|
PROP_OUTPUT_MODE
|
|
};
|
|
|
|
#define DEFAULT_CURRENT_SUBSONG 0
|
|
#define DEFAULT_SUBSONG_MODE GST_NONSTREAM_AUDIO_SUBSONG_MODE_DECODER_DEFAULT
|
|
#define DEFAULT_NUM_SUBSONGS 0
|
|
#define DEFAULT_NUM_LOOPS 0
|
|
#define DEFAULT_OUTPUT_MODE GST_NONSTREAM_AUDIO_OUTPUT_MODE_STEADY
|
|
|
|
|
|
|
|
|
|
static GstElementClass *gst_nonstream_audio_decoder_parent_class = NULL;
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_class_init (GstNonstreamAudioDecoderClass * klass);
|
|
static void gst_nonstream_audio_decoder_init (GstNonstreamAudioDecoder * dec,
|
|
GstNonstreamAudioDecoderClass * klass);
|
|
|
|
static void gst_nonstream_audio_decoder_finalize (GObject * object);
|
|
static void gst_nonstream_audio_decoder_set_property (GObject * object,
|
|
guint prop_id, GValue const *value, GParamSpec * pspec);
|
|
static void gst_nonstream_audio_decoder_get_property (GObject * object,
|
|
guint prop_id, GValue * value, GParamSpec * pspec);
|
|
|
|
static GstStateChangeReturn gst_nonstream_audio_decoder_change_state (GstElement
|
|
* element, GstStateChange transition);
|
|
|
|
static gboolean gst_nonstream_audio_decoder_sink_event (GstPad * pad,
|
|
GstObject * parent, GstEvent * event);
|
|
static gboolean gst_nonstream_audio_decoder_sink_query (GstPad * pad,
|
|
GstObject * parent, GstQuery * query);
|
|
static GstFlowReturn gst_nonstream_audio_decoder_chain (GstPad * pad,
|
|
GstObject * parent, GstBuffer * buffer);
|
|
|
|
static gboolean gst_nonstream_audio_decoder_src_event (GstPad * pad,
|
|
GstObject * parent, GstEvent * event);
|
|
static gboolean gst_nonstream_audio_decoder_src_query (GstPad * pad,
|
|
GstObject * parent, GstQuery * query);
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_set_initial_state (GstNonstreamAudioDecoder * dec);
|
|
static void gst_nonstream_audio_decoder_cleanup_state (GstNonstreamAudioDecoder
|
|
* dec);
|
|
|
|
static gboolean gst_nonstream_audio_decoder_negotiate (GstNonstreamAudioDecoder
|
|
* dec);
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_negotiate_default (GstNonstreamAudioDecoder * dec);
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_decide_allocation_default (GstNonstreamAudioDecoder
|
|
* dec, GstQuery * query);
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_propose_allocation_default (GstNonstreamAudioDecoder
|
|
* dec, GstQuery * query);
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_get_upstream_size (GstNonstreamAudioDecoder * dec,
|
|
gint64 * length);
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_load_from_buffer (GstNonstreamAudioDecoder * dec,
|
|
GstBuffer * buffer);
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_load_from_custom (GstNonstreamAudioDecoder * dec);
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_finish_load (GstNonstreamAudioDecoder * dec,
|
|
gboolean load_ok, GstClockTime initial_position,
|
|
gboolean send_stream_start);
|
|
|
|
static gboolean gst_nonstream_audio_decoder_start_task (GstNonstreamAudioDecoder
|
|
* dec);
|
|
static gboolean gst_nonstream_audio_decoder_stop_task (GstNonstreamAudioDecoder
|
|
* dec);
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_switch_to_subsong (GstNonstreamAudioDecoder * dec,
|
|
guint new_subsong, guint32 const *seqnum);
|
|
|
|
static void gst_nonstream_audio_decoder_update_toc (GstNonstreamAudioDecoder *
|
|
dec, GstNonstreamAudioDecoderClass * klass);
|
|
static void
|
|
gst_nonstream_audio_decoder_update_subsong_duration (GstNonstreamAudioDecoder *
|
|
dec, GstClockTime duration);
|
|
static void
|
|
gst_nonstream_audio_decoder_output_new_segment (GstNonstreamAudioDecoder * dec,
|
|
GstClockTime start_position);
|
|
static gboolean gst_nonstream_audio_decoder_do_seek (GstNonstreamAudioDecoder *
|
|
dec, GstEvent * event);
|
|
|
|
static GstTagList
|
|
* gst_nonstream_audio_decoder_add_main_tags (GstNonstreamAudioDecoder * dec,
|
|
GstTagList * tags);
|
|
|
|
static void gst_nonstream_audio_decoder_output_task (GstNonstreamAudioDecoder *
|
|
dec);
|
|
|
|
static char const *get_seek_type_name (GstSeekType seek_type);
|
|
|
|
|
|
|
|
|
|
static GType gst_nonstream_audio_decoder_output_mode_get_type (void);
|
|
#define GST_TYPE_NONSTREAM_AUDIO_DECODER_OUTPUT_MODE (gst_nonstream_audio_decoder_output_mode_get_type())
|
|
|
|
static GType gst_nonstream_audio_decoder_subsong_mode_get_type (void);
|
|
#define GST_TYPE_NONSTREAM_AUDIO_DECODER_SUBSONG_MODE (gst_nonstream_audio_decoder_subsong_mode_get_type())
|
|
|
|
|
|
static GType
|
|
gst_nonstream_audio_decoder_output_mode_get_type (void)
|
|
{
|
|
static GType gst_nonstream_audio_decoder_output_mode_type = 0;
|
|
|
|
if (!gst_nonstream_audio_decoder_output_mode_type) {
|
|
static GEnumValue output_mode_values[] = {
|
|
{GST_NONSTREAM_AUDIO_OUTPUT_MODE_LOOPING, "Looping output", "looping"},
|
|
{GST_NONSTREAM_AUDIO_OUTPUT_MODE_STEADY, "Steady output", "steady"},
|
|
{0, NULL, NULL},
|
|
};
|
|
|
|
gst_nonstream_audio_decoder_output_mode_type =
|
|
g_enum_register_static ("GstNonstreamAudioOutputMode",
|
|
output_mode_values);
|
|
}
|
|
|
|
return gst_nonstream_audio_decoder_output_mode_type;
|
|
}
|
|
|
|
|
|
static GType
|
|
gst_nonstream_audio_decoder_subsong_mode_get_type (void)
|
|
{
|
|
static GType gst_nonstream_audio_decoder_subsong_mode_type = 0;
|
|
|
|
if (!gst_nonstream_audio_decoder_subsong_mode_type) {
|
|
static GEnumValue subsong_mode_values[] = {
|
|
{GST_NONSTREAM_AUDIO_SUBSONG_MODE_SINGLE, "Play single subsong",
|
|
"single"},
|
|
{GST_NONSTREAM_AUDIO_SUBSONG_MODE_ALL, "Play all subsongs", "all"},
|
|
{GST_NONSTREAM_AUDIO_SUBSONG_MODE_DECODER_DEFAULT,
|
|
"Decoder specific default behavior", "default"},
|
|
{0, NULL, NULL},
|
|
};
|
|
|
|
gst_nonstream_audio_decoder_subsong_mode_type =
|
|
g_enum_register_static ("GstNonstreamAudioSubsongMode",
|
|
subsong_mode_values);
|
|
}
|
|
|
|
return gst_nonstream_audio_decoder_subsong_mode_type;
|
|
}
|
|
|
|
|
|
|
|
/* Manually defining the GType instead of using G_DEFINE_TYPE_WITH_CODE()
|
|
* because the _init() function needs to be able to access the derived
|
|
* class' sink- and srcpads */
|
|
|
|
|
|
GType
|
|
gst_nonstream_audio_decoder_get_type (void)
|
|
{
|
|
static gsize nonstream_audio_decoder_type = 0;
|
|
|
|
if (g_once_init_enter (&nonstream_audio_decoder_type)) {
|
|
GType type_;
|
|
static const GTypeInfo nonstream_audio_decoder_info = {
|
|
sizeof (GstNonstreamAudioDecoderClass),
|
|
NULL,
|
|
NULL,
|
|
(GClassInitFunc) gst_nonstream_audio_decoder_class_init,
|
|
NULL,
|
|
NULL,
|
|
sizeof (GstNonstreamAudioDecoder),
|
|
0,
|
|
(GInstanceInitFunc) gst_nonstream_audio_decoder_init,
|
|
NULL
|
|
};
|
|
|
|
type_ = g_type_register_static (GST_TYPE_ELEMENT,
|
|
"GstNonstreamAudioDecoder",
|
|
&nonstream_audio_decoder_info, G_TYPE_FLAG_ABSTRACT);
|
|
g_once_init_leave (&nonstream_audio_decoder_type, type_);
|
|
}
|
|
|
|
return nonstream_audio_decoder_type;
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_class_init (GstNonstreamAudioDecoderClass * klass)
|
|
{
|
|
GObjectClass *object_class;
|
|
GstElementClass *element_class;
|
|
|
|
object_class = G_OBJECT_CLASS (klass);
|
|
element_class = GST_ELEMENT_CLASS (klass);
|
|
|
|
gst_nonstream_audio_decoder_parent_class = g_type_class_peek_parent (klass);
|
|
|
|
GST_DEBUG_CATEGORY_INIT (nonstream_audiodecoder_debug,
|
|
"nonstreamaudiodecoder", 0, "nonstream audio decoder base class");
|
|
|
|
object_class->finalize =
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_finalize);
|
|
object_class->set_property =
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_set_property);
|
|
object_class->get_property =
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_get_property);
|
|
element_class->change_state =
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_change_state);
|
|
|
|
klass->seek = NULL;
|
|
klass->tell = NULL;
|
|
|
|
klass->load_from_buffer = NULL;
|
|
klass->load_from_custom = NULL;
|
|
|
|
klass->get_main_tags = NULL;
|
|
|
|
klass->get_current_subsong = NULL;
|
|
klass->set_current_subsong = NULL;
|
|
|
|
klass->get_num_subsongs = NULL;
|
|
klass->get_subsong_duration = NULL;
|
|
klass->get_subsong_tags = NULL;
|
|
klass->set_subsong_mode = NULL;
|
|
|
|
klass->set_num_loops = NULL;
|
|
klass->get_num_loops = NULL;
|
|
|
|
klass->decode = NULL;
|
|
|
|
klass->negotiate =
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_negotiate_default);
|
|
|
|
klass->decide_allocation =
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_decide_allocation_default);
|
|
klass->propose_allocation =
|
|
GST_DEBUG_FUNCPTR
|
|
(gst_nonstream_audio_decoder_propose_allocation_default);
|
|
|
|
klass->loads_from_sinkpad = TRUE;
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_CURRENT_SUBSONG,
|
|
g_param_spec_uint ("current-subsong",
|
|
"Currently active subsong",
|
|
"Subsong that is currently selected for playback",
|
|
0, G_MAXUINT,
|
|
DEFAULT_CURRENT_SUBSONG, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
|
|
);
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_SUBSONG_MODE,
|
|
g_param_spec_enum ("subsong-mode",
|
|
"Subsong mode",
|
|
"Mode which defines how to treat subsongs",
|
|
GST_TYPE_NONSTREAM_AUDIO_DECODER_SUBSONG_MODE,
|
|
DEFAULT_SUBSONG_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
|
|
);
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_NUM_LOOPS,
|
|
g_param_spec_int ("num-loops",
|
|
"Number of playback loops",
|
|
"Number of times a playback loop shall be executed (special values: 0 = no looping; -1 = infinite loop)",
|
|
-1, G_MAXINT,
|
|
DEFAULT_NUM_LOOPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
|
|
);
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_OUTPUT_MODE,
|
|
g_param_spec_enum ("output-mode",
|
|
"Output mode",
|
|
"Which mode playback shall use when a loop is encountered; looping = reset position to start of loop, steady = do not reset position",
|
|
GST_TYPE_NONSTREAM_AUDIO_DECODER_OUTPUT_MODE,
|
|
DEFAULT_OUTPUT_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
|
|
);
|
|
}
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_init (GstNonstreamAudioDecoder * dec,
|
|
GstNonstreamAudioDecoderClass * klass)
|
|
{
|
|
GstPadTemplate *pad_template;
|
|
|
|
/* These are set here, not in gst_nonstream_audio_decoder_set_initial_state(),
|
|
* because these are values for the properties; they are not supposed to be
|
|
* reset in the READY->NULL state change */
|
|
dec->current_subsong = DEFAULT_CURRENT_SUBSONG;
|
|
dec->subsong_mode = DEFAULT_SUBSONG_MODE;
|
|
dec->output_mode = DEFAULT_OUTPUT_MODE;
|
|
dec->num_loops = DEFAULT_NUM_LOOPS;
|
|
|
|
/* Calling this here, not in the NULL->READY state change,
|
|
* to make sure get_property calls return valid values */
|
|
gst_nonstream_audio_decoder_set_initial_state (dec);
|
|
|
|
dec->input_data_adapter = gst_adapter_new ();
|
|
g_mutex_init (&(dec->mutex));
|
|
|
|
{
|
|
/* set up src pad */
|
|
|
|
pad_template =
|
|
gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "src");
|
|
g_return_if_fail (pad_template != NULL); /* derived class is supposed to define a src pad template */
|
|
|
|
dec->srcpad = gst_pad_new_from_template (pad_template, "src");
|
|
gst_pad_set_event_function (dec->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_src_event));
|
|
gst_pad_set_query_function (dec->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_src_query));
|
|
gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad);
|
|
}
|
|
|
|
if (klass->loads_from_sinkpad) {
|
|
/* set up sink pad if this class loads from a sinkpad */
|
|
|
|
pad_template =
|
|
gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "sink");
|
|
g_return_if_fail (pad_template != NULL); /* derived class is supposed to define a sink pad template */
|
|
|
|
dec->sinkpad = gst_pad_new_from_template (pad_template, "sink");
|
|
gst_pad_set_event_function (dec->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_sink_event));
|
|
gst_pad_set_query_function (dec->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_sink_query));
|
|
gst_pad_set_chain_function (dec->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_nonstream_audio_decoder_chain));
|
|
gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_finalize (GObject * object)
|
|
{
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (object);
|
|
|
|
g_mutex_clear (&(dec->mutex));
|
|
g_object_unref (G_OBJECT (dec->input_data_adapter));
|
|
|
|
G_OBJECT_CLASS (gst_nonstream_audio_decoder_parent_class)->finalize (object);
|
|
}
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_set_property (GObject * object, guint prop_id,
|
|
GValue const *value, GParamSpec * pspec)
|
|
{
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (object);
|
|
GstNonstreamAudioDecoderClass *klass =
|
|
GST_NONSTREAM_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
switch (prop_id) {
|
|
case PROP_OUTPUT_MODE:
|
|
{
|
|
GstNonstreamAudioOutputMode new_output_mode;
|
|
new_output_mode = g_value_get_enum (value);
|
|
|
|
g_assert (klass->get_supported_output_modes);
|
|
|
|
if ((klass->get_supported_output_modes (dec) & (1u << new_output_mode)) ==
|
|
0) {
|
|
GST_WARNING_OBJECT (dec,
|
|
"could not set output mode to %s (not supported by subclass)",
|
|
(new_output_mode ==
|
|
GST_NONSTREAM_AUDIO_OUTPUT_MODE_STEADY) ? "steady" : "looping");
|
|
break;
|
|
}
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
if (new_output_mode != dec->output_mode) {
|
|
gboolean proceed = TRUE;
|
|
|
|
if (dec->loaded_mode) {
|
|
GstClockTime cur_position;
|
|
|
|
if (klass->set_output_mode != NULL) {
|
|
if (klass->set_output_mode (dec, new_output_mode, &cur_position))
|
|
proceed = TRUE;
|
|
else {
|
|
proceed = FALSE;
|
|
GST_WARNING_OBJECT (dec, "switching to new output mode failed");
|
|
}
|
|
} else {
|
|
GST_DEBUG_OBJECT (dec,
|
|
"cannot call set_output_mode, since it is NULL");
|
|
proceed = FALSE;
|
|
}
|
|
|
|
if (proceed) {
|
|
gst_nonstream_audio_decoder_output_new_segment (dec, cur_position);
|
|
dec->output_mode = new_output_mode;
|
|
}
|
|
}
|
|
|
|
if (proceed) {
|
|
/* store output mode in case the property is set before the media got loaded */
|
|
dec->output_mode = new_output_mode;
|
|
}
|
|
}
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
break;
|
|
}
|
|
|
|
case PROP_CURRENT_SUBSONG:
|
|
{
|
|
guint new_subsong = g_value_get_uint (value);
|
|
gst_nonstream_audio_decoder_switch_to_subsong (dec, new_subsong, NULL);
|
|
|
|
break;
|
|
}
|
|
|
|
case PROP_SUBSONG_MODE:
|
|
{
|
|
GstNonstreamAudioSubsongMode new_subsong_mode = g_value_get_enum (value);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
if (new_subsong_mode != dec->subsong_mode) {
|
|
gboolean proceed = TRUE;
|
|
|
|
if (dec->loaded_mode) {
|
|
GstClockTime cur_position;
|
|
|
|
if (klass->set_subsong_mode != NULL) {
|
|
if (klass->set_subsong_mode (dec, new_subsong_mode, &cur_position))
|
|
proceed = TRUE;
|
|
else {
|
|
proceed = FALSE;
|
|
GST_WARNING_OBJECT (dec, "switching to new subsong mode failed");
|
|
}
|
|
} else {
|
|
GST_DEBUG_OBJECT (dec,
|
|
"cannot call set_subsong_mode, since it is NULL");
|
|
proceed = FALSE;
|
|
}
|
|
|
|
if (proceed) {
|
|
if (GST_CLOCK_TIME_IS_VALID (cur_position))
|
|
gst_nonstream_audio_decoder_output_new_segment (dec,
|
|
cur_position);
|
|
dec->subsong_mode = new_subsong_mode;
|
|
}
|
|
}
|
|
|
|
if (proceed) {
|
|
/* store subsong mode in case the property is set before the media got loaded */
|
|
dec->subsong_mode = new_subsong_mode;
|
|
}
|
|
}
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
break;
|
|
}
|
|
|
|
case PROP_NUM_LOOPS:
|
|
{
|
|
gint new_num_loops = g_value_get_int (value);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
if (new_num_loops != dec->num_loops) {
|
|
if (dec->loaded_mode) {
|
|
if (klass->set_num_loops != NULL) {
|
|
if (!(klass->set_num_loops (dec, new_num_loops)))
|
|
GST_WARNING_OBJECT (dec, "setting number of loops to %u failed",
|
|
new_num_loops);
|
|
} else
|
|
GST_DEBUG_OBJECT (dec,
|
|
"cannot call set_num_loops, since it is NULL");
|
|
}
|
|
|
|
/* store number of loops in case the property is set before the media got loaded */
|
|
dec->num_loops = new_num_loops;
|
|
}
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_OUTPUT_MODE:
|
|
{
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
g_value_set_enum (value, dec->output_mode);
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
break;
|
|
}
|
|
|
|
case PROP_CURRENT_SUBSONG:
|
|
{
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
g_value_set_uint (value, dec->current_subsong);
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
break;
|
|
}
|
|
|
|
case PROP_SUBSONG_MODE:
|
|
{
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
g_value_set_enum (value, dec->subsong_mode);
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
break;
|
|
}
|
|
|
|
case PROP_NUM_LOOPS:
|
|
{
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
g_value_set_int (value, dec->num_loops);
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static GstStateChangeReturn
|
|
gst_nonstream_audio_decoder_change_state (GstElement * element,
|
|
GstStateChange transition)
|
|
{
|
|
GstStateChangeReturn ret;
|
|
|
|
ret =
|
|
GST_ELEMENT_CLASS (gst_nonstream_audio_decoder_parent_class)->change_state
|
|
(element, transition);
|
|
if (ret == GST_STATE_CHANGE_FAILURE)
|
|
return ret;
|
|
|
|
switch (transition) {
|
|
case GST_STATE_CHANGE_READY_TO_PAUSED:
|
|
{
|
|
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (element);
|
|
GstNonstreamAudioDecoderClass *klass =
|
|
GST_NONSTREAM_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
/* For decoders that load with some custom method,
|
|
* this is now the time to load
|
|
*
|
|
* It is done *after* calling the parent class' change_state vfunc,
|
|
* since the pad states need to be set up in order for the loading
|
|
* to succeed, since it will try to push a new_caps event
|
|
* downstream etc. (upwards state changes typically are handled
|
|
* *before* calling the parent class' change_state vfunc ; this is
|
|
* a special case) */
|
|
if (!(klass->loads_from_sinkpad) && !(dec->loaded_mode)) {
|
|
gboolean ret;
|
|
|
|
/* load_from_custom is required if loads_from_sinkpad is FALSE */
|
|
g_assert (klass->load_from_custom != NULL);
|
|
|
|
ret = gst_nonstream_audio_decoder_load_from_custom (dec);
|
|
|
|
if (!ret) {
|
|
GST_ERROR_OBJECT (dec, "loading from custom source failed");
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
}
|
|
|
|
if (!gst_nonstream_audio_decoder_start_task (dec))
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case GST_STATE_CHANGE_PAUSED_TO_READY:
|
|
{
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (element);
|
|
if (!gst_nonstream_audio_decoder_stop_task (dec))
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
break;
|
|
}
|
|
|
|
case GST_STATE_CHANGE_READY_TO_NULL:
|
|
{
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (element);
|
|
|
|
/* In the READY->NULL state change, reset the decoder to an
|
|
* initial state ensure it can be used for a fresh new session */
|
|
gst_nonstream_audio_decoder_cleanup_state (dec);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_sink_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event)
|
|
{
|
|
gboolean res = FALSE;
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (parent);
|
|
|
|
switch (GST_EVENT_TYPE (event)) {
|
|
case GST_EVENT_SEGMENT:
|
|
{
|
|
/* Upstream sends in a byte segment, which is uninteresting here,
|
|
* since a custom segment event is generated anyway */
|
|
gst_event_unref (event);
|
|
res = TRUE;
|
|
break;
|
|
}
|
|
|
|
case GST_EVENT_EOS:
|
|
{
|
|
gsize avail_size;
|
|
GstBuffer *adapter_buffer;
|
|
|
|
if (dec->loaded_mode) {
|
|
/* If media has already been loaded, then the decoder
|
|
* task has been started; the EOS event can be ignored */
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"EOS received after media was loaded -> ignoring");
|
|
res = TRUE;
|
|
} else {
|
|
/* take all data in the input data adapter,
|
|
* and try to load the media from it */
|
|
|
|
avail_size = gst_adapter_available (dec->input_data_adapter);
|
|
if (avail_size == 0) {
|
|
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL),
|
|
("EOS event raised, but no data was received - cannot load anything"));
|
|
return FALSE;
|
|
}
|
|
|
|
adapter_buffer =
|
|
gst_adapter_take_buffer (dec->input_data_adapter, avail_size);
|
|
|
|
if (!gst_nonstream_audio_decoder_load_from_buffer (dec, adapter_buffer)) {
|
|
return FALSE;
|
|
}
|
|
|
|
res = gst_nonstream_audio_decoder_start_task (dec);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
res = gst_pad_event_default (pad, parent, event);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_sink_query (GstPad * pad, GstObject * parent,
|
|
GstQuery * query)
|
|
{
|
|
gboolean res = FALSE;
|
|
GstNonstreamAudioDecoder *dec;
|
|
GstNonstreamAudioDecoderClass *klass;
|
|
|
|
dec = GST_NONSTREAM_AUDIO_DECODER (parent);
|
|
klass = GST_NONSTREAM_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
switch (GST_QUERY_TYPE (query)) {
|
|
case GST_QUERY_ALLOCATION:
|
|
{
|
|
if (klass->propose_allocation != NULL)
|
|
res = klass->propose_allocation (dec, query);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
res = gst_pad_query_default (pad, parent, query);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
static GstFlowReturn
|
|
gst_nonstream_audio_decoder_chain (G_GNUC_UNUSED GstPad * pad,
|
|
GstObject * parent, GstBuffer * buffer)
|
|
{
|
|
GstFlowReturn flow_ret = GST_FLOW_OK;
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (parent);
|
|
|
|
/* query upstream size in bytes to know how many bytes to expect
|
|
* this is a safety measure to prevent the case when upstream never
|
|
* reaches EOS (or only after a long time) and we keep loading and
|
|
* loading and eventually run out of memory */
|
|
if (dec->upstream_size < 0) {
|
|
if (!gst_nonstream_audio_decoder_get_upstream_size (dec,
|
|
&(dec->upstream_size))) {
|
|
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL),
|
|
("Cannot load - upstream size (in bytes) could not be determined"));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
}
|
|
|
|
if (dec->loaded_mode) {
|
|
/* media is already loaded - discard any incoming
|
|
* buffers, since they are not needed */
|
|
|
|
GST_DEBUG_OBJECT (dec, "received data after media was loaded - ignoring");
|
|
|
|
gst_buffer_unref (buffer);
|
|
} else {
|
|
/* accumulate data until end-of-stream or the upstream
|
|
* size is reached, then load media and commence playback */
|
|
|
|
gint64 avail_size;
|
|
|
|
gst_adapter_push (dec->input_data_adapter, buffer);
|
|
avail_size = gst_adapter_available (dec->input_data_adapter);
|
|
if (avail_size >= dec->upstream_size) {
|
|
GstBuffer *adapter_buffer =
|
|
gst_adapter_take_buffer (dec->input_data_adapter, avail_size);
|
|
|
|
if (gst_nonstream_audio_decoder_load_from_buffer (dec, adapter_buffer))
|
|
flow_ret =
|
|
gst_nonstream_audio_decoder_start_task (dec) ? GST_FLOW_OK :
|
|
GST_FLOW_ERROR;
|
|
else
|
|
flow_ret = GST_FLOW_ERROR;
|
|
}
|
|
}
|
|
|
|
return flow_ret;
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_src_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event)
|
|
{
|
|
gboolean res = FALSE;
|
|
GstNonstreamAudioDecoder *dec = GST_NONSTREAM_AUDIO_DECODER (parent);
|
|
|
|
switch (GST_EVENT_TYPE (event)) {
|
|
case GST_EVENT_SEEK:
|
|
{
|
|
res = gst_nonstream_audio_decoder_do_seek (dec, event);
|
|
break;
|
|
}
|
|
|
|
case GST_EVENT_TOC_SELECT:
|
|
{
|
|
/* NOTE: This event may be received multiple times if it
|
|
* was originally sent to a bin containing multiple sink
|
|
* elements (for example, playbin). This is OK and does
|
|
* not break anything. */
|
|
|
|
gchar *uid = NULL;
|
|
guint subsong_idx = 0;
|
|
guint32 seqnum;
|
|
|
|
gst_event_parse_toc_select (event, &uid);
|
|
|
|
if ((uid != NULL)
|
|
&& (sscanf (uid, "nonstream-subsong-%05u", &subsong_idx) == 1)) {
|
|
seqnum = gst_event_get_seqnum (event);
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"received TOC select event (sequence number %" G_GUINT32_FORMAT
|
|
"), switching to subsong %u", seqnum, subsong_idx);
|
|
|
|
gst_nonstream_audio_decoder_switch_to_subsong (dec, subsong_idx,
|
|
&seqnum);
|
|
}
|
|
|
|
g_free (uid);
|
|
|
|
res = TRUE;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
res = gst_pad_event_default (pad, parent, event);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_src_query (GstPad * pad, GstObject * parent,
|
|
GstQuery * query)
|
|
{
|
|
gboolean res = FALSE;
|
|
GstNonstreamAudioDecoder *dec;
|
|
GstNonstreamAudioDecoderClass *klass;
|
|
|
|
dec = GST_NONSTREAM_AUDIO_DECODER (parent);
|
|
klass = GST_NONSTREAM_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
switch (GST_QUERY_TYPE (query)) {
|
|
case GST_QUERY_DURATION:
|
|
{
|
|
GstFormat format;
|
|
GST_TRACE_OBJECT (parent, "duration query");
|
|
|
|
if (!(dec->loaded_mode)) {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"cannot respond to duration query: nothing is loaded yet");
|
|
break;
|
|
}
|
|
|
|
GST_TRACE_OBJECT (parent, "parsing duration query");
|
|
gst_query_parse_duration (query, &format, NULL);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
if ((format == GST_FORMAT_TIME)
|
|
&& (dec->subsong_duration != GST_CLOCK_TIME_NONE)) {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"responding to query with duration %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (dec->subsong_duration));
|
|
gst_query_set_duration (query, format, dec->subsong_duration);
|
|
res = TRUE;
|
|
} else if (format != GST_FORMAT_TIME)
|
|
GST_DEBUG_OBJECT (parent,
|
|
"cannot respond to duration query: format is %s, expected time format",
|
|
gst_format_get_name (format));
|
|
else if (dec->subsong_duration == GST_CLOCK_TIME_NONE)
|
|
GST_DEBUG_OBJECT (parent,
|
|
"cannot respond to duration query: no valid subsong duration available");
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
break;
|
|
}
|
|
|
|
case GST_QUERY_POSITION:
|
|
{
|
|
GstFormat format;
|
|
if (!(dec->loaded_mode)) {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"cannot respond to position query: nothing is loaded yet");
|
|
break;
|
|
}
|
|
|
|
if (klass->tell == NULL) {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"cannot respond to position query: subclass does not have tell() function defined");
|
|
break;
|
|
}
|
|
|
|
gst_query_parse_position (query, &format, NULL);
|
|
if (format == GST_FORMAT_TIME) {
|
|
GstClockTime pos;
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
pos = klass->tell (dec);
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
GST_DEBUG_OBJECT (parent,
|
|
"position query received with format TIME -> reporting position %"
|
|
GST_TIME_FORMAT, GST_TIME_ARGS (pos));
|
|
gst_query_set_position (query, format, pos);
|
|
res = TRUE;
|
|
} else {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"position query received with unsupported format %s -> not reporting anything",
|
|
gst_format_get_name (format));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case GST_QUERY_SEEKING:
|
|
{
|
|
GstFormat fmt;
|
|
GstClockTime duration;
|
|
|
|
if (!dec->loaded_mode) {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"cannot respond to seeking query: nothing is loaded yet");
|
|
break;
|
|
}
|
|
|
|
if (klass->seek == NULL) {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"cannot respond to seeking query: subclass does not have seek() function defined");
|
|
break;
|
|
}
|
|
|
|
gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
duration = dec->subsong_duration;
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
if (fmt == GST_FORMAT_TIME) {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"seeking query received with format TIME -> can seek: yes");
|
|
gst_query_set_seeking (query, fmt, TRUE, 0, duration);
|
|
res = TRUE;
|
|
} else {
|
|
GST_DEBUG_OBJECT (parent,
|
|
"seeking query received with unsupported format %s -> can seek: no",
|
|
gst_format_get_name (fmt));
|
|
gst_query_set_seeking (query, fmt, FALSE, 0, -1);
|
|
res = TRUE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
res = gst_pad_query_default (pad, parent, query);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_set_initial_state (GstNonstreamAudioDecoder * dec)
|
|
{
|
|
dec->upstream_size = -1;
|
|
dec->loaded_mode = FALSE;
|
|
|
|
dec->subsong_duration = GST_CLOCK_TIME_NONE;
|
|
|
|
dec->output_format_changed = FALSE;
|
|
gst_audio_info_init (&(dec->output_audio_info));
|
|
dec->num_decoded_samples = 0;
|
|
dec->cur_pos_in_samples = 0;
|
|
gst_segment_init (&(dec->cur_segment), GST_FORMAT_TIME);
|
|
dec->discont = FALSE;
|
|
|
|
dec->toc = NULL;
|
|
|
|
dec->allocator = NULL;
|
|
}
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_cleanup_state (GstNonstreamAudioDecoder * dec)
|
|
{
|
|
gst_adapter_clear (dec->input_data_adapter);
|
|
|
|
if (dec->allocator != NULL) {
|
|
gst_object_unref (dec->allocator);
|
|
dec->allocator = NULL;
|
|
}
|
|
|
|
if (dec->toc != NULL) {
|
|
gst_toc_unref (dec->toc);
|
|
dec->toc = NULL;
|
|
}
|
|
|
|
gst_nonstream_audio_decoder_set_initial_state (dec);
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_negotiate (GstNonstreamAudioDecoder * dec)
|
|
{
|
|
/* must be called with lock */
|
|
|
|
GstNonstreamAudioDecoderClass *klass;
|
|
gboolean res = TRUE;
|
|
|
|
klass = GST_NONSTREAM_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
/* protected by a mutex, since the allocator might currently be in use */
|
|
if (klass->negotiate != NULL)
|
|
res = klass->negotiate (dec);
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_negotiate_default (GstNonstreamAudioDecoder * dec)
|
|
{
|
|
/* mutex is locked when this is called */
|
|
|
|
GstCaps *caps;
|
|
GstNonstreamAudioDecoderClass *klass;
|
|
gboolean res = TRUE;
|
|
GstQuery *query = NULL;
|
|
GstAllocator *allocator;
|
|
GstAllocationParams allocation_params;
|
|
|
|
g_return_val_if_fail (GST_IS_NONSTREAM_AUDIO_DECODER (dec), FALSE);
|
|
g_return_val_if_fail (GST_AUDIO_INFO_IS_VALID (&(dec->output_audio_info)),
|
|
FALSE);
|
|
|
|
klass = GST_NONSTREAM_AUDIO_DECODER_CLASS (G_OBJECT_GET_CLASS (dec));
|
|
|
|
caps = gst_audio_info_to_caps (&(dec->output_audio_info));
|
|
|
|
GST_DEBUG_OBJECT (dec, "setting src caps %" GST_PTR_FORMAT, (gpointer) caps);
|
|
|
|
res = gst_pad_push_event (dec->srcpad, gst_event_new_caps (caps));
|
|
/* clear any pending reconfigure flag */
|
|
gst_pad_check_reconfigure (dec->srcpad);
|
|
|
|
if (!res) {
|
|
GST_WARNING_OBJECT (dec, "could not push new caps event downstream");
|
|
goto done;
|
|
}
|
|
|
|
GST_TRACE_OBJECT (dec, "src caps set");
|
|
|
|
dec->output_format_changed = FALSE;
|
|
|
|
query = gst_query_new_allocation (caps, TRUE);
|
|
if (!gst_pad_peer_query (dec->srcpad, query)) {
|
|
GST_DEBUG_OBJECT (dec, "didn't get downstream ALLOCATION hints");
|
|
}
|
|
|
|
g_assert (klass->decide_allocation != NULL);
|
|
res = klass->decide_allocation (dec, query);
|
|
|
|
GST_DEBUG_OBJECT (dec, "ALLOCATION (%d) params: %" GST_PTR_FORMAT, res,
|
|
(gpointer) query);
|
|
|
|
if (!res)
|
|
goto no_decide_allocation;
|
|
|
|
/* we got configuration from our peer or the decide_allocation method,
|
|
* parse them */
|
|
if (gst_query_get_n_allocation_params (query) > 0) {
|
|
gst_query_parse_nth_allocation_param (query, 0, &allocator,
|
|
&allocation_params);
|
|
} else {
|
|
allocator = NULL;
|
|
gst_allocation_params_init (&allocation_params);
|
|
}
|
|
|
|
if (dec->allocator != NULL)
|
|
gst_object_unref (dec->allocator);
|
|
dec->allocator = allocator;
|
|
dec->allocation_params = allocation_params;
|
|
|
|
done:
|
|
if (query != NULL)
|
|
gst_query_unref (query);
|
|
gst_caps_unref (caps);
|
|
|
|
return res;
|
|
|
|
no_decide_allocation:
|
|
{
|
|
GST_WARNING_OBJECT (dec, "subclass failed to decide allocation");
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_decide_allocation_default (G_GNUC_UNUSED
|
|
GstNonstreamAudioDecoder * dec, GstQuery * query)
|
|
{
|
|
GstAllocator *allocator = NULL;
|
|
GstAllocationParams params;
|
|
gboolean update_allocator;
|
|
|
|
/* we got configuration from our peer or the decide_allocation method,
|
|
* parse them */
|
|
if (gst_query_get_n_allocation_params (query) > 0) {
|
|
/* try the allocator */
|
|
gst_query_parse_nth_allocation_param (query, 0, &allocator, ¶ms);
|
|
update_allocator = TRUE;
|
|
} else {
|
|
allocator = NULL;
|
|
gst_allocation_params_init (¶ms);
|
|
update_allocator = FALSE;
|
|
}
|
|
|
|
if (update_allocator)
|
|
gst_query_set_nth_allocation_param (query, 0, allocator, ¶ms);
|
|
else
|
|
gst_query_add_allocation_param (query, allocator, ¶ms);
|
|
|
|
if (allocator)
|
|
gst_object_unref (allocator);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_propose_allocation_default (G_GNUC_UNUSED
|
|
GstNonstreamAudioDecoder * dec, G_GNUC_UNUSED GstQuery * query)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_get_upstream_size (GstNonstreamAudioDecoder * dec,
|
|
gint64 * length)
|
|
{
|
|
return gst_pad_peer_query_duration (dec->sinkpad, GST_FORMAT_BYTES, length)
|
|
&& (*length >= 0);
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_load_from_buffer (GstNonstreamAudioDecoder * dec,
|
|
GstBuffer * buffer)
|
|
{
|
|
gboolean load_ok;
|
|
GstClockTime initial_position;
|
|
GstNonstreamAudioDecoderClass *klass;
|
|
gboolean ret;
|
|
|
|
klass = GST_NONSTREAM_AUDIO_DECODER_CLASS (G_OBJECT_GET_CLASS (dec));
|
|
g_assert (klass->load_from_buffer != NULL);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
|
|
GST_LOG_OBJECT (dec, "read %" G_GSIZE_FORMAT " bytes from upstream",
|
|
gst_buffer_get_size (buffer));
|
|
|
|
initial_position = 0;
|
|
load_ok =
|
|
klass->load_from_buffer (dec, buffer, dec->current_subsong,
|
|
dec->subsong_mode, &initial_position, &(dec->output_mode),
|
|
&(dec->num_loops));
|
|
gst_buffer_unref (buffer);
|
|
|
|
ret =
|
|
gst_nonstream_audio_decoder_finish_load (dec, load_ok, initial_position,
|
|
FALSE);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_load_from_custom (GstNonstreamAudioDecoder * dec)
|
|
{
|
|
gboolean load_ok;
|
|
GstClockTime initial_position;
|
|
GstNonstreamAudioDecoderClass *klass;
|
|
gboolean ret;
|
|
|
|
klass = GST_NONSTREAM_AUDIO_DECODER_CLASS (G_OBJECT_GET_CLASS (dec));
|
|
g_assert (klass->load_from_custom != NULL);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
|
|
GST_LOG_OBJECT (dec,
|
|
"reading song from custom source defined by derived class");
|
|
|
|
initial_position = 0;
|
|
load_ok =
|
|
klass->load_from_custom (dec, dec->current_subsong, dec->subsong_mode,
|
|
&initial_position, &(dec->output_mode), &(dec->num_loops));
|
|
|
|
ret =
|
|
gst_nonstream_audio_decoder_finish_load (dec, load_ok, initial_position,
|
|
TRUE);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_finish_load (GstNonstreamAudioDecoder * dec,
|
|
gboolean load_ok, GstClockTime initial_position, gboolean send_stream_start)
|
|
{
|
|
/* must be called with lock */
|
|
|
|
GstNonstreamAudioDecoderClass *klass =
|
|
GST_NONSTREAM_AUDIO_DECODER_CLASS (G_OBJECT_GET_CLASS (dec));
|
|
|
|
GST_TRACE_OBJECT (dec, "enter finish_load");
|
|
|
|
|
|
/* Prerequisites */
|
|
|
|
if (!load_ok) {
|
|
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("Loading failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GST_AUDIO_INFO_IS_VALID (&(dec->output_audio_info))) {
|
|
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL),
|
|
("Audio info is invalid after loading"));
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/* Log the number of available subsongs */
|
|
if (klass->get_num_subsongs != NULL)
|
|
GST_DEBUG_OBJECT (dec, "%u subsong(s) available",
|
|
klass->get_num_subsongs (dec));
|
|
|
|
|
|
/* Set the current subsong (or use the default value) */
|
|
if (klass->get_current_subsong != NULL) {
|
|
GST_TRACE_OBJECT (dec, "requesting current subsong");
|
|
dec->current_subsong = klass->get_current_subsong (dec);
|
|
}
|
|
|
|
|
|
/* Handle the subsong duration */
|
|
if (klass->get_subsong_duration != NULL) {
|
|
GstClockTime duration;
|
|
GST_TRACE_OBJECT (dec, "requesting subsong duration");
|
|
duration = klass->get_subsong_duration (dec, dec->current_subsong);
|
|
gst_nonstream_audio_decoder_update_subsong_duration (dec, duration);
|
|
}
|
|
|
|
|
|
/* Send tags downstream (if some exist) */
|
|
if (klass->get_subsong_tags != NULL) {
|
|
/* Subsong tags available */
|
|
|
|
GstTagList *tags;
|
|
GST_TRACE_OBJECT (dec, "requesting subsong tags");
|
|
tags = klass->get_subsong_tags (dec, dec->current_subsong);
|
|
if (tags != NULL)
|
|
tags = gst_nonstream_audio_decoder_add_main_tags (dec, tags);
|
|
if (tags != NULL)
|
|
gst_pad_push_event (dec->srcpad, gst_event_new_tag (tags));
|
|
} else {
|
|
/* No subsong tags - just send main tags out */
|
|
|
|
GstTagList *tags = gst_tag_list_new_empty ();
|
|
tags = gst_nonstream_audio_decoder_add_main_tags (dec, tags);
|
|
gst_pad_push_event (dec->srcpad, gst_event_new_tag (tags));
|
|
}
|
|
|
|
|
|
/* Send stream start downstream if requested */
|
|
if (send_stream_start) {
|
|
gchar *stream_id;
|
|
GstEvent *event;
|
|
|
|
stream_id =
|
|
gst_pad_create_stream_id (dec->srcpad, GST_ELEMENT_CAST (dec), NULL);
|
|
GST_DEBUG_OBJECT (dec, "pushing STREAM_START with stream id \"%s\"",
|
|
stream_id);
|
|
|
|
event = gst_event_new_stream_start (stream_id);
|
|
gst_event_set_group_id (event, gst_util_group_id_next ());
|
|
gst_pad_push_event (dec->srcpad, event);
|
|
g_free (stream_id);
|
|
}
|
|
|
|
|
|
/* Update the table of contents */
|
|
gst_nonstream_audio_decoder_update_toc (dec, klass);
|
|
|
|
|
|
/* Negotiate output caps and an allocator */
|
|
GST_TRACE_OBJECT (dec, "negotiating caps and allocator");
|
|
if (!gst_nonstream_audio_decoder_negotiate (dec)) {
|
|
GST_ERROR_OBJECT (dec, "negotiation failed - aborting load");
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/* Send new segment downstream */
|
|
gst_nonstream_audio_decoder_output_new_segment (dec, initial_position);
|
|
|
|
dec->loaded_mode = TRUE;
|
|
|
|
GST_TRACE_OBJECT (dec, "exit finish_load");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_start_task (GstNonstreamAudioDecoder * dec)
|
|
{
|
|
if (!gst_pad_start_task (dec->srcpad,
|
|
(GstTaskFunction) gst_nonstream_audio_decoder_output_task, dec,
|
|
NULL)) {
|
|
GST_ERROR_OBJECT (dec, "could not start decoder output task");
|
|
return FALSE;
|
|
} else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_stop_task (GstNonstreamAudioDecoder * dec)
|
|
{
|
|
if (!gst_pad_stop_task (dec->srcpad)) {
|
|
GST_ERROR_OBJECT (dec, "could not stop decoder output task");
|
|
return FALSE;
|
|
} else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_switch_to_subsong (GstNonstreamAudioDecoder * dec,
|
|
guint new_subsong, guint32 const *seqnum)
|
|
{
|
|
gboolean ret = TRUE;
|
|
GstNonstreamAudioDecoderClass *klass =
|
|
GST_NONSTREAM_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
|
|
if (klass->set_current_subsong == NULL) {
|
|
/* If set_current_subsong wasn't set by the subclass, then
|
|
* subsongs are not supported. It is not an error if this
|
|
* function is called in that case, since it might happen
|
|
* because the current-subsong property was set (and since
|
|
* this is a base class property, it is always available). */
|
|
GST_DEBUG_OBJECT (dec, "cannot call set_current_subsong, since it is NULL");
|
|
goto finish;
|
|
}
|
|
|
|
if (dec->loaded_mode) {
|
|
GstEvent *fevent;
|
|
GstClockTime new_position;
|
|
GstClockTime new_subsong_duration = GST_CLOCK_TIME_NONE;
|
|
|
|
|
|
/* Check if (a) new_subsong is already the current subsong
|
|
* and (b) if new_subsong exceeds the number of available
|
|
* subsongs. Do this here, when the song is loaded,
|
|
* because prior to loading, the number of subsong is usually
|
|
* not known (and the loading process might choose a specific
|
|
* subsong to be the current one at the start of playback). */
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
|
|
if (new_subsong == dec->current_subsong) {
|
|
GST_DEBUG_OBJECT (dec,
|
|
"subsong %u is already the current subsong - ignoring call",
|
|
new_subsong);
|
|
goto finish_unlock;
|
|
}
|
|
|
|
if (klass->get_num_subsongs) {
|
|
guint num_subsongs = klass->get_num_subsongs (dec);
|
|
|
|
if (new_subsong >= num_subsongs) {
|
|
GST_WARNING_OBJECT (dec,
|
|
"subsong %u is out of bounds (there are %u subsongs) - not switching",
|
|
new_subsong, num_subsongs);
|
|
goto finish_unlock;
|
|
}
|
|
}
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
|
|
/* Switching subsongs during playback is very similar to a
|
|
* flushing seek. Therefore, the stream lock must be taken,
|
|
* flush-start/flush-stop events have to be sent, and
|
|
* the pad task has to be restarted. */
|
|
|
|
|
|
fevent = gst_event_new_flush_start ();
|
|
if (seqnum != NULL) {
|
|
gst_event_set_seqnum (fevent, *seqnum);
|
|
GST_DEBUG_OBJECT (dec,
|
|
"sending flush start event with sequence number %" G_GUINT32_FORMAT,
|
|
*seqnum);
|
|
} else
|
|
GST_DEBUG_OBJECT (dec, "sending flush start event (no sequence number)");
|
|
|
|
gst_pad_push_event (dec->srcpad, gst_event_ref (fevent));
|
|
/* unlock upstream pull_range */
|
|
if (klass->loads_from_sinkpad)
|
|
gst_pad_push_event (dec->sinkpad, fevent);
|
|
else
|
|
gst_event_unref (fevent);
|
|
|
|
|
|
GST_PAD_STREAM_LOCK (dec->srcpad);
|
|
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
|
|
|
|
if (!(klass->set_current_subsong (dec, new_subsong, &new_position))) {
|
|
/* Switch failed. Do _not_ exit early from here - playback must
|
|
* continue from the current subsong, and it cannot do that if
|
|
* we exit here. Try getting the current position and proceed as
|
|
* if the switch succeeded (but set the return value to FALSE.) */
|
|
|
|
ret = FALSE;
|
|
if (klass->tell)
|
|
new_position = klass->tell (dec);
|
|
else
|
|
new_position = 0;
|
|
GST_WARNING_OBJECT (dec, "switching to new subsong %u failed",
|
|
new_subsong);
|
|
}
|
|
|
|
/* Flushing seek resets the base time, which means num_decoded_samples
|
|
* needs to be set to 0, since it defines the segment.base value */
|
|
dec->num_decoded_samples = 0;
|
|
|
|
|
|
fevent = gst_event_new_flush_stop (TRUE);
|
|
if (seqnum != NULL) {
|
|
gst_event_set_seqnum (fevent, *seqnum);
|
|
GST_DEBUG_OBJECT (dec,
|
|
"sending flush stop event with sequence number %" G_GUINT32_FORMAT,
|
|
*seqnum);
|
|
} else
|
|
GST_DEBUG_OBJECT (dec, "sending flush stop event (no sequence number)");
|
|
|
|
gst_pad_push_event (dec->srcpad, gst_event_ref (fevent));
|
|
/* unlock upstream pull_range */
|
|
if (klass->loads_from_sinkpad)
|
|
gst_pad_push_event (dec->sinkpad, fevent);
|
|
else
|
|
gst_event_unref (fevent);
|
|
|
|
|
|
/* use the new subsong's duration (if one exists) */
|
|
if (klass->get_subsong_duration != NULL)
|
|
new_subsong_duration = klass->get_subsong_duration (dec, new_subsong);
|
|
gst_nonstream_audio_decoder_update_subsong_duration (dec,
|
|
new_subsong_duration);
|
|
|
|
/* create a new segment for the new subsong */
|
|
gst_nonstream_audio_decoder_output_new_segment (dec, new_position);
|
|
|
|
/* use the new subsong's tags (if any exist) */
|
|
if (klass->get_subsong_tags != NULL) {
|
|
GstTagList *subsong_tags = klass->get_subsong_tags (dec, new_subsong);
|
|
if (subsong_tags != NULL)
|
|
subsong_tags =
|
|
gst_nonstream_audio_decoder_add_main_tags (dec, subsong_tags);
|
|
if (subsong_tags != NULL)
|
|
gst_pad_push_event (dec->srcpad, gst_event_new_tag (subsong_tags));
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (dec, "successfully switched to new subsong %u",
|
|
new_subsong);
|
|
dec->current_subsong = new_subsong;
|
|
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
|
|
/* Subsong has been switched, and all necessary events have been
|
|
* pushed downstream. Restart srcpad task. */
|
|
gst_nonstream_audio_decoder_start_task (dec);
|
|
|
|
/* Unlock stream, we are done */
|
|
GST_PAD_STREAM_UNLOCK (dec->srcpad);
|
|
} else {
|
|
/* If song hasn't been loaded yet, then playback cannot currently
|
|
* been happening. In this case, a "switch" is simple - just store
|
|
* the current subsong index. When the song is loaded, it will
|
|
* start playing this subsong. */
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"playback hasn't started yet - storing subsong index %u as the current subsong",
|
|
new_subsong);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
dec->current_subsong = new_subsong;
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
}
|
|
|
|
|
|
finish:
|
|
return ret;
|
|
|
|
|
|
finish_unlock:
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
goto finish;
|
|
}
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_update_toc (GstNonstreamAudioDecoder * dec,
|
|
GstNonstreamAudioDecoderClass * klass)
|
|
{
|
|
/* must be called with lock */
|
|
|
|
guint num_subsongs, i;
|
|
|
|
if (dec->toc != NULL) {
|
|
gst_toc_unref (dec->toc);
|
|
dec->toc = NULL;
|
|
}
|
|
|
|
if (klass->get_num_subsongs == NULL)
|
|
return;
|
|
|
|
num_subsongs = klass->get_num_subsongs (dec);
|
|
if (num_subsongs <= 1) {
|
|
GST_DEBUG_OBJECT (dec, "no need for a TOC since there is only one subsong");
|
|
return;
|
|
}
|
|
|
|
dec->toc = gst_toc_new (GST_TOC_SCOPE_GLOBAL);
|
|
|
|
if (klass->get_main_tags) {
|
|
GstTagList *main_tags = klass->get_main_tags (dec);
|
|
if (main_tags)
|
|
gst_toc_set_tags (dec->toc, main_tags);
|
|
}
|
|
|
|
for (i = 0; i < num_subsongs; ++i) {
|
|
gchar *uid;
|
|
GstTocEntry *entry;
|
|
GstClockTime duration;
|
|
GstTagList *tags;
|
|
|
|
duration =
|
|
(klass->get_subsong_duration !=
|
|
NULL) ? klass->get_subsong_duration (dec, i) : GST_CLOCK_TIME_NONE;
|
|
tags =
|
|
(klass->get_subsong_tags != NULL) ? klass->get_subsong_tags (dec,
|
|
i) : NULL;
|
|
if (!tags)
|
|
tags = gst_tag_list_new_empty ();
|
|
|
|
uid = g_strdup_printf ("nonstream-subsong-%05u", i);
|
|
entry = gst_toc_entry_new (GST_TOC_ENTRY_TYPE_TRACK, uid);
|
|
/* Set the UID as title tag for TOC entry if no title already present */
|
|
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP, GST_TAG_TITLE, uid, NULL);
|
|
/* Set the subsong duration as duration tag for TOC entry if no duration already present */
|
|
if (duration != GST_CLOCK_TIME_NONE)
|
|
gst_tag_list_add (tags, GST_TAG_MERGE_KEEP, GST_TAG_DURATION, duration,
|
|
NULL);
|
|
|
|
/* FIXME: TOC does not allow GST_CLOCK_TIME_NONE as a stop value */
|
|
if (duration == GST_CLOCK_TIME_NONE)
|
|
duration = G_MAXINT64;
|
|
|
|
/* Subsongs always start at 00:00 */
|
|
gst_toc_entry_set_start_stop_times (entry, 0, duration);
|
|
gst_toc_entry_set_tags (entry, tags);
|
|
|
|
/* NOTE: *not* adding loop count via gst_toc_entry_set_loop(), since
|
|
* in GstNonstreamAudioDecoder, looping is a playback property, not
|
|
* a property of the subsongs themselves */
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"new toc entry: uid: \"%s\" duration: %" GST_TIME_FORMAT " tags: %"
|
|
GST_PTR_FORMAT, uid, GST_TIME_ARGS (duration), (gpointer) tags);
|
|
|
|
gst_toc_append_entry (dec->toc, entry);
|
|
|
|
g_free (uid);
|
|
}
|
|
|
|
gst_pad_push_event (dec->srcpad, gst_event_new_toc (dec->toc, FALSE));
|
|
}
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_update_subsong_duration (GstNonstreamAudioDecoder *
|
|
dec, GstClockTime duration)
|
|
{
|
|
/* must be called with lock */
|
|
|
|
dec->subsong_duration = duration;
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
gst_element_post_message (GST_ELEMENT (dec),
|
|
gst_message_new_duration_changed (GST_OBJECT (dec)));
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
}
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_output_new_segment (GstNonstreamAudioDecoder * dec,
|
|
GstClockTime start_position)
|
|
{
|
|
/* must be called with lock */
|
|
|
|
GstSegment segment;
|
|
|
|
gst_segment_init (&segment, GST_FORMAT_TIME);
|
|
|
|
segment.base =
|
|
gst_util_uint64_scale_int (dec->num_decoded_samples, GST_SECOND,
|
|
dec->output_audio_info.rate);
|
|
segment.start = 0;
|
|
segment.time = start_position;
|
|
segment.offset = 0;
|
|
segment.position = 0;
|
|
|
|
/* note that num_decoded_samples isn't being reset; it is the
|
|
* analogue to the segment base value, and thus is supposed to
|
|
* monotonically increase, except for when a flushing seek happens
|
|
* (since a flushing seek is supposed to be a fresh restart for
|
|
* the whole pipeline) */
|
|
dec->cur_pos_in_samples = 0;
|
|
|
|
/* stop/duration members are not set, on purpose - in case of loops,
|
|
* new segments will be generated, which automatically put an implicit
|
|
* end on the current segment (the segment implicitly "ends" when the
|
|
* new one starts), and having a stop value might cause very slight
|
|
* gaps occasionally due to slight jitter in the calculation of
|
|
* base times etc. */
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"output new segment with base %" GST_TIME_FORMAT " time %"
|
|
GST_TIME_FORMAT, GST_TIME_ARGS (segment.base),
|
|
GST_TIME_ARGS (segment.time));
|
|
|
|
dec->cur_segment = segment;
|
|
dec->discont = TRUE;
|
|
|
|
gst_pad_push_event (dec->srcpad, gst_event_new_segment (&segment));
|
|
}
|
|
|
|
|
|
static gboolean
|
|
gst_nonstream_audio_decoder_do_seek (GstNonstreamAudioDecoder * dec,
|
|
GstEvent * event)
|
|
{
|
|
gboolean res;
|
|
gdouble rate;
|
|
GstFormat format;
|
|
GstSeekFlags flags;
|
|
GstSeekType start_type, stop_type;
|
|
GstClockTime new_position;
|
|
gint64 start, stop;
|
|
GstSegment segment;
|
|
guint32 seqnum;
|
|
gboolean flush;
|
|
GstNonstreamAudioDecoderClass *klass =
|
|
GST_NONSTREAM_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
if (klass->seek == NULL) {
|
|
GST_DEBUG_OBJECT (dec,
|
|
"cannot seek: subclass does not have seek() function defined");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!dec->loaded_mode) {
|
|
GST_DEBUG_OBJECT (dec, "nothing loaded yet - cannot seek");
|
|
return FALSE;
|
|
}
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
if (!GST_AUDIO_INFO_IS_VALID (&(dec->output_audio_info))) {
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
GST_DEBUG_OBJECT (dec, "no valid output audioinfo present - cannot seek");
|
|
return FALSE;
|
|
}
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
|
|
GST_DEBUG_OBJECT (dec, "starting seek");
|
|
|
|
gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
|
|
&stop_type, &stop);
|
|
seqnum = gst_event_get_seqnum (event);
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"seek event data: "
|
|
"rate %f format %s "
|
|
"start type %s start %" GST_TIME_FORMAT " "
|
|
"stop type %s stop %" GST_TIME_FORMAT,
|
|
rate, gst_format_get_name (format),
|
|
get_seek_type_name (start_type), GST_TIME_ARGS (start),
|
|
get_seek_type_name (stop_type), GST_TIME_ARGS (stop)
|
|
);
|
|
|
|
if (format != GST_FORMAT_TIME) {
|
|
GST_DEBUG_OBJECT (dec, "seeking is only supported in TIME format");
|
|
return FALSE;
|
|
}
|
|
|
|
if (rate < 0) {
|
|
GST_DEBUG_OBJECT (dec, "only positive seek rates are supported");
|
|
return FALSE;
|
|
}
|
|
|
|
flush = ((flags & GST_SEEK_FLAG_FLUSH) == GST_SEEK_FLAG_FLUSH);
|
|
|
|
if (flush) {
|
|
GstEvent *fevent = gst_event_new_flush_start ();
|
|
gst_event_set_seqnum (fevent, seqnum);
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"sending flush start event with sequence number %" G_GUINT32_FORMAT,
|
|
seqnum);
|
|
|
|
gst_pad_push_event (dec->srcpad, gst_event_ref (fevent));
|
|
/* unlock upstream pull_range */
|
|
if (klass->loads_from_sinkpad)
|
|
gst_pad_push_event (dec->sinkpad, fevent);
|
|
else
|
|
gst_event_unref (fevent);
|
|
} else
|
|
gst_pad_pause_task (dec->srcpad);
|
|
|
|
GST_PAD_STREAM_LOCK (dec->srcpad);
|
|
|
|
segment = dec->cur_segment;
|
|
|
|
if (!gst_segment_do_seek (&segment,
|
|
rate, format, flags, start_type, start, stop_type, stop, NULL)) {
|
|
GST_DEBUG_OBJECT (dec, "could not seek in segment");
|
|
GST_PAD_STREAM_UNLOCK (dec->srcpad);
|
|
return FALSE;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"segment data: "
|
|
"seek event data: "
|
|
"rate %f applied rate %f "
|
|
"format %s "
|
|
"base %" GST_TIME_FORMAT " "
|
|
"offset %" GST_TIME_FORMAT " "
|
|
"start %" GST_TIME_FORMAT " "
|
|
"stop %" GST_TIME_FORMAT " "
|
|
"time %" GST_TIME_FORMAT " "
|
|
"position %" GST_TIME_FORMAT " "
|
|
"duration %" GST_TIME_FORMAT,
|
|
segment.rate, segment.applied_rate,
|
|
gst_format_get_name (segment.format),
|
|
GST_TIME_ARGS (segment.base),
|
|
GST_TIME_ARGS (segment.offset),
|
|
GST_TIME_ARGS (segment.start),
|
|
GST_TIME_ARGS (segment.stop),
|
|
GST_TIME_ARGS (segment.time),
|
|
GST_TIME_ARGS (segment.position), GST_TIME_ARGS (segment.duration)
|
|
);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
|
|
new_position = segment.position;
|
|
res = klass->seek (dec, &new_position);
|
|
segment.position = new_position;
|
|
|
|
dec->cur_segment = segment;
|
|
dec->cur_pos_in_samples =
|
|
gst_util_uint64_scale_int (dec->cur_segment.position,
|
|
dec->output_audio_info.rate, GST_SECOND);
|
|
dec->num_decoded_samples = 0;
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
if (flush) {
|
|
GstEvent *fevent = gst_event_new_flush_stop (TRUE);
|
|
gst_event_set_seqnum (fevent, seqnum);
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"sending flush stop event with sequence number %" G_GUINT32_FORMAT,
|
|
seqnum);
|
|
|
|
gst_pad_push_event (dec->srcpad, gst_event_ref (fevent));
|
|
if (klass->loads_from_sinkpad)
|
|
gst_pad_push_event (dec->sinkpad, fevent);
|
|
else
|
|
gst_event_unref (fevent);
|
|
}
|
|
|
|
if (res) {
|
|
if (flags & GST_SEEK_FLAG_SEGMENT) {
|
|
GST_DEBUG_OBJECT (dec, "posting SEGMENT_START message");
|
|
|
|
gst_element_post_message (GST_ELEMENT (dec),
|
|
gst_message_new_segment_start (GST_OBJECT (dec),
|
|
GST_FORMAT_TIME, segment.start)
|
|
);
|
|
}
|
|
|
|
gst_pad_push_event (dec->srcpad, gst_event_new_segment (&segment));
|
|
|
|
GST_INFO_OBJECT (dec, "seek succeeded");
|
|
|
|
gst_nonstream_audio_decoder_start_task (dec);
|
|
} else {
|
|
GST_WARNING_OBJECT (dec, "seek failed");
|
|
}
|
|
|
|
GST_PAD_STREAM_UNLOCK (dec->srcpad);
|
|
|
|
gst_event_unref (event);
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
static GstTagList *
|
|
gst_nonstream_audio_decoder_add_main_tags (GstNonstreamAudioDecoder * dec,
|
|
GstTagList * tags)
|
|
{
|
|
GstNonstreamAudioDecoderClass *klass =
|
|
GST_NONSTREAM_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
if (!klass->get_main_tags)
|
|
return tags;
|
|
|
|
tags = gst_tag_list_make_writable (tags);
|
|
if (tags) {
|
|
GstClockTime duration;
|
|
GstTagList *main_tags;
|
|
|
|
/* Get main tags. If some exist, merge them with the given tags,
|
|
* and return the merged result. Otherwise, just return the given tags. */
|
|
main_tags = klass->get_main_tags (dec);
|
|
if (main_tags) {
|
|
tags = gst_tag_list_merge (main_tags, tags, GST_TAG_MERGE_REPLACE);
|
|
gst_tag_list_unref (main_tags);
|
|
}
|
|
|
|
/* Add subsong duration if available */
|
|
duration = dec->subsong_duration;
|
|
if (GST_CLOCK_TIME_IS_VALID (duration))
|
|
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_DURATION, duration,
|
|
NULL);
|
|
|
|
return tags;
|
|
} else {
|
|
GST_ERROR_OBJECT (dec, "could not make subsong tags writable");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
gst_nonstream_audio_decoder_output_task (GstNonstreamAudioDecoder * dec)
|
|
{
|
|
GstFlowReturn flow;
|
|
GstBuffer *outbuf;
|
|
guint num_samples;
|
|
|
|
GstNonstreamAudioDecoderClass *klass;
|
|
klass = GST_NONSTREAM_AUDIO_DECODER_CLASS (G_OBJECT_GET_CLASS (dec));
|
|
g_assert (klass->decode != NULL);
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_LOCK_MUTEX (dec);
|
|
|
|
/* perform the actual decoding */
|
|
if (!(klass->decode (dec, &outbuf, &num_samples))) {
|
|
/* EOS case */
|
|
GST_INFO_OBJECT (dec, "decode() reports end -> sending EOS event");
|
|
gst_pad_push_event (dec->srcpad, gst_event_new_eos ());
|
|
goto pause_unlock;
|
|
}
|
|
|
|
if (outbuf == NULL) {
|
|
GST_ERROR_OBJECT (outbuf, "decode() produced NULL buffer");
|
|
goto pause_unlock;
|
|
}
|
|
|
|
/* set the buffer's metadata */
|
|
GST_BUFFER_DURATION (outbuf) =
|
|
gst_util_uint64_scale_int (num_samples, GST_SECOND,
|
|
dec->output_audio_info.rate);
|
|
GST_BUFFER_OFFSET (outbuf) = dec->cur_pos_in_samples;
|
|
GST_BUFFER_OFFSET_END (outbuf) = dec->cur_pos_in_samples + num_samples;
|
|
GST_BUFFER_PTS (outbuf) =
|
|
gst_util_uint64_scale_int (dec->cur_pos_in_samples, GST_SECOND,
|
|
dec->output_audio_info.rate);
|
|
GST_BUFFER_DTS (outbuf) = GST_BUFFER_PTS (outbuf);
|
|
|
|
if (G_UNLIKELY (dec->discont)) {
|
|
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
|
|
dec->discont = FALSE;
|
|
}
|
|
|
|
GST_LOG_OBJECT (dec,
|
|
"output buffer stats: num_samples = %u duration = %" GST_TIME_FORMAT
|
|
" cur_pos_in_samples = %" G_GUINT64_FORMAT " timestamp = %"
|
|
GST_TIME_FORMAT, num_samples,
|
|
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), dec->cur_pos_in_samples,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf))
|
|
);
|
|
|
|
/* increment sample counters */
|
|
dec->cur_pos_in_samples += num_samples;
|
|
dec->num_decoded_samples += num_samples;
|
|
|
|
/* the decode() call might have set a new output format -> renegotiate
|
|
* before sending the new buffer downstream */
|
|
if (G_UNLIKELY (dec->output_format_changed ||
|
|
(GST_AUDIO_INFO_IS_VALID (&(dec->output_audio_info))
|
|
&& gst_pad_check_reconfigure (dec->srcpad))
|
|
)) {
|
|
if (!gst_nonstream_audio_decoder_negotiate (dec)) {
|
|
gst_buffer_unref (outbuf);
|
|
GST_LOG_OBJECT (dec, "could not push output buffer: negotiation failed");
|
|
goto pause_unlock;
|
|
}
|
|
}
|
|
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
|
|
/* push new samples downstream
|
|
* no need to unref buffer - gst_pad_push() does it in
|
|
* all cases (success and failure) */
|
|
flow = gst_pad_push (dec->srcpad, outbuf);
|
|
switch (flow) {
|
|
case GST_FLOW_OK:
|
|
break;
|
|
|
|
case GST_FLOW_FLUSHING:
|
|
GST_LOG_OBJECT (dec, "pipeline is being flushed - pausing task");
|
|
goto pause;
|
|
|
|
case GST_FLOW_NOT_NEGOTIATED:
|
|
if (gst_pad_needs_reconfigure (dec->srcpad)) {
|
|
GST_DEBUG_OBJECT (dec, "trying to renegotiate");
|
|
break;
|
|
}
|
|
/* fallthrough to default */
|
|
|
|
default:
|
|
GST_ELEMENT_ERROR (dec, STREAM, FAILED, ("Internal data flow error."),
|
|
("streaming task paused, reason %s (%d)", gst_flow_get_name (flow),
|
|
flow));
|
|
}
|
|
|
|
return;
|
|
|
|
pause:
|
|
GST_INFO_OBJECT (dec, "pausing task");
|
|
/* NOT using stop_task here, since that would cause a deadlock.
|
|
* See the gst_pad_stop_task() documentation for details. */
|
|
gst_pad_pause_task (dec->srcpad);
|
|
return;
|
|
pause_unlock:
|
|
GST_NONSTREAM_AUDIO_DECODER_UNLOCK_MUTEX (dec);
|
|
goto pause;
|
|
}
|
|
|
|
|
|
static char const *
|
|
get_seek_type_name (GstSeekType seek_type)
|
|
{
|
|
switch (seek_type) {
|
|
case GST_SEEK_TYPE_NONE:
|
|
return "none";
|
|
case GST_SEEK_TYPE_SET:
|
|
return "set";
|
|
case GST_SEEK_TYPE_END:
|
|
return "end";
|
|
default:
|
|
return "<unknown>";
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* gst_nonstream_audio_decoder_handle_loop:
|
|
* @dec: a #GstNonstreamAudioDecoder
|
|
* @new_position New position the next loop starts with
|
|
*
|
|
* Reports that a loop has been completed and creates a new appropriate
|
|
* segment for the next loop.
|
|
*
|
|
* @new_position exists because a loop may not start at the beginning.
|
|
*
|
|
* This function is only useful for subclasses which can be in the
|
|
* GST_NONSTREAM_AUDIO_OUTPUT_MODE_LOOPING output mode, since in the
|
|
* GST_NONSTREAM_AUDIO_OUTPUT_MODE_STEADY output mode, this function
|
|
* does nothing. See #GstNonstreamAudioOutputMode for more details.
|
|
*
|
|
* The subclass calls this during playback when it loops. It produces
|
|
* a new segment with updated base time and internal time values, to allow
|
|
* for seamless looping. It does *not* check the number of elapsed loops;
|
|
* this is up the subclass.
|
|
*
|
|
* Note that if this function is called, then it must be done after the
|
|
* last samples of the loop have been decoded and pushed downstream.
|
|
*
|
|
* This function must be called with the decoder mutex lock held, since it
|
|
* is typically called from within @decode (which in turn are called with
|
|
* the lock already held).
|
|
*/
|
|
void
|
|
gst_nonstream_audio_decoder_handle_loop (GstNonstreamAudioDecoder * dec,
|
|
GstClockTime new_position)
|
|
{
|
|
if (dec->output_mode == GST_NONSTREAM_AUDIO_OUTPUT_MODE_STEADY) {
|
|
/* handle_loop makes no sense with open-ended decoders */
|
|
GST_WARNING_OBJECT (dec,
|
|
"ignoring handle_loop() call, since the decoder output mode is \"steady\"");
|
|
return;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (dec,
|
|
"handle_loop() invoked with new_position = %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (new_position));
|
|
|
|
dec->discont = TRUE;
|
|
|
|
gst_nonstream_audio_decoder_output_new_segment (dec, new_position);
|
|
}
|
|
|
|
|
|
/**
|
|
* gst_nonstream_audio_decoder_set_output_format:
|
|
* @dec: a #GstNonstreamAudioDecoder
|
|
* @audio_info: Valid audio info structure containing the output format
|
|
*
|
|
* Sets the output caps by means of a GstAudioInfo structure.
|
|
*
|
|
* This must be called latest in the first @decode call, to ensure src caps are
|
|
* set before decoded samples are sent downstream. Typically, this is called
|
|
* from inside @load_from_buffer or @load_from_custom.
|
|
*
|
|
* This function must be called with the decoder mutex lock held, since it
|
|
* is typically called from within the aforementioned vfuncs (which in turn
|
|
* are called with the lock already held).
|
|
*
|
|
* Returns: TRUE if setting the output format succeeded, FALSE otherwise
|
|
*/
|
|
gboolean
|
|
gst_nonstream_audio_decoder_set_output_format (GstNonstreamAudioDecoder * dec,
|
|
GstAudioInfo const *audio_info)
|
|
{
|
|
GstCaps *caps;
|
|
GstCaps *templ_caps;
|
|
gboolean caps_ok;
|
|
gboolean res = TRUE;
|
|
|
|
g_return_val_if_fail (GST_IS_NONSTREAM_AUDIO_DECODER (dec), FALSE);
|
|
|
|
caps = gst_audio_info_to_caps (audio_info);
|
|
if (caps == NULL) {
|
|
GST_WARNING_OBJECT (dec, "Could not create caps out of audio info");
|
|
return FALSE;
|
|
}
|
|
|
|
templ_caps = gst_pad_get_pad_template_caps (dec->srcpad);
|
|
caps_ok = gst_caps_is_subset (caps, templ_caps);
|
|
|
|
if (caps_ok) {
|
|
dec->output_audio_info = *audio_info;
|
|
dec->output_format_changed = TRUE;
|
|
|
|
GST_INFO_OBJECT (dec, "setting output format to %" GST_PTR_FORMAT,
|
|
(gpointer) caps);
|
|
} else {
|
|
GST_WARNING_OBJECT (dec,
|
|
"requested output format %" GST_PTR_FORMAT " does not match template %"
|
|
GST_PTR_FORMAT, (gpointer) caps, (gpointer) templ_caps);
|
|
|
|
res = FALSE;
|
|
}
|
|
|
|
gst_caps_unref (caps);
|
|
gst_caps_unref (templ_caps);
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
/**
|
|
* gst_nonstream_audio_decoder_set_output_format_simple:
|
|
* @dec: a #GstNonstreamAudioDecoder
|
|
* @sample_rate: Output sample rate to use, in Hz
|
|
* @sample_format: Output sample format to use
|
|
* @num_channels: Number of output channels to use
|
|
*
|
|
* Convenience function; sets the output caps by means of common parameters.
|
|
*
|
|
* Internally, this fills a GstAudioInfo structure and calls
|
|
* gst_nonstream_audio_decoder_set_output_format().
|
|
*
|
|
* Returns: TRUE if setting the output format succeeded, FALSE otherwise
|
|
*/
|
|
gboolean
|
|
gst_nonstream_audio_decoder_set_output_format_simple (GstNonstreamAudioDecoder *
|
|
dec, guint sample_rate, GstAudioFormat sample_format, guint num_channels)
|
|
{
|
|
GstAudioInfo output_audio_info;
|
|
|
|
gst_audio_info_init (&output_audio_info);
|
|
|
|
gst_audio_info_set_format (&output_audio_info,
|
|
sample_format, sample_rate, num_channels, NULL);
|
|
|
|
return gst_nonstream_audio_decoder_set_output_format (dec,
|
|
&output_audio_info);
|
|
}
|
|
|
|
|
|
/**
|
|
* gst_nonstream_audio_decoder_get_downstream_info:
|
|
* @dec: a #GstNonstreamAudioDecoder
|
|
* @format: #GstAudioFormat value to fill with a sample format
|
|
* @sample_rate: Integer to fill with a sample rate
|
|
* @num_channels: Integer to fill with a channel count
|
|
*
|
|
* Gets sample format, sample rate, channel count from the allowed srcpad caps.
|
|
*
|
|
* This is useful for when the subclass wishes to adjust one or more output
|
|
* parameters to whatever downstream is supporting. For example, the output
|
|
* sample rate is often a freely adjustable value in module players.
|
|
*
|
|
* This function tries to find a value inside the srcpad peer's caps for
|
|
* @format, @sample_rate, @num_chnanels . Any of these can be NULL; they
|
|
* (and the corresponding downstream caps) are then skipped while retrieving
|
|
* information. Non-fixated caps are fixated first; the value closest to
|
|
* their present value is then chosen. For example, if the variables pointed
|
|
* to by the arguments are GST_AUDIO_FORMAT_16, 48000 Hz, and 2 channels,
|
|
* and the downstream caps are:
|
|
*
|
|
* "audio/x-raw, format={S16LE,S32LE}, rate=[1,32000], channels=[1,MAX]"
|
|
*
|
|
* Then @format and @channels stay the same, while @sample_rate is set to 32000 Hz.
|
|
* This way, the initial values the the variables pointed to by the arguments
|
|
* are set to can be used as default output values. Note that if no downstream
|
|
* caps can be retrieved, then this function does nothing, therefore it is
|
|
* necessary to ensure that @format, @sample_rate, and @channels have valid
|
|
* initial values.
|
|
*
|
|
* Decoder lock is not held by this function, so it can be called from within
|
|
* any of the class vfuncs.
|
|
*/
|
|
void
|
|
gst_nonstream_audio_decoder_get_downstream_info (GstNonstreamAudioDecoder * dec,
|
|
GstAudioFormat * format, gint * sample_rate, gint * num_channels)
|
|
{
|
|
GstCaps *allowed_srccaps;
|
|
guint structure_nr, num_structures;
|
|
gboolean ds_format_found = FALSE, ds_rate_found = FALSE, ds_channels_found =
|
|
FALSE;
|
|
|
|
g_return_if_fail (GST_IS_NONSTREAM_AUDIO_DECODER (dec));
|
|
|
|
allowed_srccaps = gst_pad_get_allowed_caps (dec->srcpad);
|
|
if (allowed_srccaps == NULL) {
|
|
GST_INFO_OBJECT (dec,
|
|
"no downstream caps available - not modifying arguments");
|
|
return;
|
|
}
|
|
|
|
num_structures = gst_caps_get_size (allowed_srccaps);
|
|
GST_DEBUG_OBJECT (dec, "%u structure(s) in downstream caps", num_structures);
|
|
for (structure_nr = 0; structure_nr < num_structures; ++structure_nr) {
|
|
GstStructure *structure;
|
|
|
|
ds_format_found = FALSE;
|
|
ds_rate_found = FALSE;
|
|
ds_channels_found = FALSE;
|
|
|
|
structure = gst_caps_get_structure (allowed_srccaps, structure_nr);
|
|
|
|
/* If all formats which need to be queried are present in the structure,
|
|
* check its contents */
|
|
if (((format == NULL) || gst_structure_has_field (structure, "format")) &&
|
|
((sample_rate == NULL) || gst_structure_has_field (structure, "rate"))
|
|
&& ((num_channels == NULL)
|
|
|| gst_structure_has_field (structure, "channels"))) {
|
|
gint fixated_sample_rate;
|
|
gint fixated_num_channels;
|
|
GstAudioFormat fixated_format = 0;
|
|
GstStructure *fixated_str;
|
|
gboolean passed = TRUE;
|
|
|
|
/* Make a copy of the structure, since we need to modify
|
|
* (fixate) values inside */
|
|
fixated_str = gst_structure_copy (structure);
|
|
|
|
/* Try to fixate and retrieve the sample format */
|
|
if (passed && (format != NULL)) {
|
|
passed = FALSE;
|
|
|
|
if ((gst_structure_get_field_type (fixated_str,
|
|
"format") == G_TYPE_STRING)
|
|
|| gst_structure_fixate_field_string (fixated_str, "format",
|
|
gst_audio_format_to_string (*format))) {
|
|
gchar const *fmt_str =
|
|
gst_structure_get_string (fixated_str, "format");
|
|
if (fmt_str
|
|
&& ((fixated_format =
|
|
gst_audio_format_from_string (fmt_str)) !=
|
|
GST_AUDIO_FORMAT_UNKNOWN)) {
|
|
GST_DEBUG_OBJECT (dec, "found fixated format: %s", fmt_str);
|
|
ds_format_found = TRUE;
|
|
passed = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Try to fixate and retrieve the sample rate */
|
|
if (passed && (sample_rate != NULL)) {
|
|
passed = FALSE;
|
|
|
|
if ((gst_structure_get_field_type (fixated_str, "rate") == G_TYPE_INT)
|
|
|| gst_structure_fixate_field_nearest_int (fixated_str, "rate",
|
|
*sample_rate)) {
|
|
if (gst_structure_get_int (fixated_str, "rate", &fixated_sample_rate)) {
|
|
GST_DEBUG_OBJECT (dec, "found fixated sample rate: %d",
|
|
fixated_sample_rate);
|
|
ds_rate_found = TRUE;
|
|
passed = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Try to fixate and retrieve the channel count */
|
|
if (passed && (num_channels != NULL)) {
|
|
passed = FALSE;
|
|
|
|
if ((gst_structure_get_field_type (fixated_str,
|
|
"channels") == G_TYPE_INT)
|
|
|| gst_structure_fixate_field_nearest_int (fixated_str, "channels",
|
|
*num_channels)) {
|
|
if (gst_structure_get_int (fixated_str, "channels",
|
|
&fixated_num_channels)) {
|
|
GST_DEBUG_OBJECT (dec, "found fixated channel count: %d",
|
|
fixated_num_channels);
|
|
ds_channels_found = TRUE;
|
|
passed = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
gst_structure_free (fixated_str);
|
|
|
|
if (ds_format_found && ds_rate_found && ds_channels_found) {
|
|
*format = fixated_format;
|
|
*sample_rate = fixated_sample_rate;
|
|
*num_channels = fixated_num_channels;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
gst_caps_unref (allowed_srccaps);
|
|
|
|
if ((format != NULL) && !ds_format_found)
|
|
GST_INFO_OBJECT (dec,
|
|
"downstream did not specify format - using default (%s)",
|
|
gst_audio_format_to_string (*format));
|
|
if ((sample_rate != NULL) && !ds_rate_found)
|
|
GST_INFO_OBJECT (dec,
|
|
"downstream did not specify sample rate - using default (%d Hz)",
|
|
*sample_rate);
|
|
if ((num_channels != NULL) && !ds_channels_found)
|
|
GST_INFO_OBJECT (dec,
|
|
"downstream did not specify number of channels - using default (%d channels)",
|
|
*num_channels);
|
|
}
|
|
|
|
|
|
/**
|
|
* gst_nonstream_audio_decoder_allocate_output_buffer:
|
|
* @dec: Decoder instance
|
|
* @size: Size of the output buffer, in bytes
|
|
*
|
|
* Allocates an output buffer with the internally configured buffer pool.
|
|
*
|
|
* This function may only be called from within @load_from_buffer,
|
|
* @load_from_custom, and @decode.
|
|
*
|
|
* Returns: Newly allocated output buffer, or NULL if allocation failed
|
|
*/
|
|
GstBuffer *
|
|
gst_nonstream_audio_decoder_allocate_output_buffer (GstNonstreamAudioDecoder *
|
|
dec, gsize size)
|
|
{
|
|
if (G_UNLIKELY (dec->output_format_changed ||
|
|
(GST_AUDIO_INFO_IS_VALID (&(dec->output_audio_info))
|
|
&& gst_pad_check_reconfigure (dec->srcpad))
|
|
)) {
|
|
/* renegotiate if necessary, before allocating,
|
|
* to make sure the right allocator and the right allocation
|
|
* params are used */
|
|
if (!gst_nonstream_audio_decoder_negotiate (dec)) {
|
|
GST_ERROR_OBJECT (dec,
|
|
"could not allocate output buffer because negotiation failed");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return gst_buffer_new_allocate (dec->allocator, size,
|
|
&(dec->allocation_params));
|
|
}
|