mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-24 17:20:36 +00:00
3606 lines
103 KiB
C
3606 lines
103 KiB
C
/* GStreamer
|
|
* Copyright (C) 2009 Igalia S.L.
|
|
* Author: Iago Toral Quiroga <itoral@igalia.com>
|
|
* Copyright (C) 2011 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>.
|
|
* Copyright (C) 2011 Nokia Corporation. All rights reserved.
|
|
* Contact: Stefan Kost <stefan.kost@nokia.com>
|
|
*
|
|
* 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:gstaudiodecoder
|
|
* @title: GstAudioDecoder
|
|
* @short_description: Base class for audio decoders
|
|
* @see_also: #GstBaseTransform
|
|
*
|
|
* This base class is for audio decoders turning encoded data into
|
|
* raw audio samples.
|
|
*
|
|
* GstAudioDecoder and subclass should cooperate as follows.
|
|
*
|
|
* ## Configuration
|
|
*
|
|
* * Initially, GstAudioDecoder calls @start when the decoder element
|
|
* is activated, which allows subclass to perform any global setup.
|
|
* Base class (context) parameters can already be set according to subclass
|
|
* capabilities (or possibly upon receive more information in subsequent
|
|
* @set_format).
|
|
* * GstAudioDecoder calls @set_format to inform subclass of the format
|
|
* of input audio data that it is about to receive.
|
|
* While unlikely, it might be called more than once, if changing input
|
|
* parameters require reconfiguration.
|
|
* * GstAudioDecoder calls @stop at end of all processing.
|
|
*
|
|
* As of configuration stage, and throughout processing, GstAudioDecoder
|
|
* provides various (context) parameters, e.g. describing the format of
|
|
* output audio data (valid when output caps have been set) or current parsing state.
|
|
* Conversely, subclass can and should configure context to inform
|
|
* base class of its expectation w.r.t. buffer handling.
|
|
*
|
|
* ## Data processing
|
|
* * Base class gathers input data, and optionally allows subclass
|
|
* to parse this into subsequently manageable (as defined by subclass)
|
|
* chunks. Such chunks are subsequently referred to as 'frames',
|
|
* though they may or may not correspond to 1 (or more) audio format frame.
|
|
* * Input frame is provided to subclass' @handle_frame.
|
|
* * If codec processing results in decoded data, subclass should call
|
|
* @gst_audio_decoder_finish_frame to have decoded data pushed
|
|
* downstream.
|
|
* * Just prior to actually pushing a buffer downstream,
|
|
* it is passed to @pre_push. Subclass should either use this callback
|
|
* to arrange for additional downstream pushing or otherwise ensure such
|
|
* custom pushing occurs after at least a method call has finished since
|
|
* setting src pad caps.
|
|
* * During the parsing process GstAudioDecoderClass will handle both
|
|
* srcpad and sinkpad events. Sink events will be passed to subclass
|
|
* if @event callback has been provided.
|
|
*
|
|
* ## Shutdown phase
|
|
*
|
|
* * GstAudioDecoder class calls @stop to inform the subclass that data
|
|
* parsing will be stopped.
|
|
*
|
|
* Subclass is responsible for providing pad template caps for
|
|
* source and sink pads. The pads need to be named "sink" and "src". It also
|
|
* needs to set the fixed caps on srcpad, when the format is ensured. This
|
|
* is typically when base class calls subclass' @set_format function, though
|
|
* it might be delayed until calling @gst_audio_decoder_finish_frame.
|
|
*
|
|
* In summary, above process should have subclass concentrating on
|
|
* codec data processing while leaving other matters to base class,
|
|
* such as most notably timestamp handling. While it may exert more control
|
|
* in this area (see e.g. @pre_push), it is very much not recommended.
|
|
*
|
|
* In particular, base class will try to arrange for perfect output timestamps
|
|
* as much as possible while tracking upstream timestamps.
|
|
* To this end, if deviation between the next ideal expected perfect timestamp
|
|
* and upstream exceeds #GstAudioDecoder:tolerance, then resync to upstream
|
|
* occurs (which would happen always if the tolerance mechanism is disabled).
|
|
*
|
|
* In non-live pipelines, baseclass can also (configurably) arrange for
|
|
* output buffer aggregation which may help to redue large(r) numbers of
|
|
* small(er) buffers being pushed and processed downstream.
|
|
*
|
|
* On the other hand, it should be noted that baseclass only provides limited
|
|
* seeking support (upon explicit subclass request), as full-fledged support
|
|
* should rather be left to upstream demuxer, parser or alike. This simple
|
|
* approach caters for seeking and duration reporting using estimated input
|
|
* bitrates.
|
|
*
|
|
* Things that subclass need to take care of:
|
|
*
|
|
* * Provide pad templates
|
|
* * Set source pad caps when appropriate
|
|
* * Set user-configurable properties to sane defaults for format and
|
|
* implementing codec at hand, and convey some subclass capabilities and
|
|
* expectations in context.
|
|
*
|
|
* * Accept data in @handle_frame and provide encoded results to
|
|
* @gst_audio_decoder_finish_frame. If it is prepared to perform
|
|
* PLC, it should also accept NULL data in @handle_frame and provide for
|
|
* data for indicated duration.
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "gstaudiodecoder.h"
|
|
#include "gstaudioutilsprivate.h"
|
|
#include <gst/pbutils/descriptions.h>
|
|
|
|
#include <string.h>
|
|
|
|
GST_DEBUG_CATEGORY (audiodecoder_debug);
|
|
#define GST_CAT_DEFAULT audiodecoder_debug
|
|
|
|
#define GST_AUDIO_DECODER_GET_PRIVATE(obj) \
|
|
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_AUDIO_DECODER, \
|
|
GstAudioDecoderPrivate))
|
|
|
|
enum
|
|
{
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_LATENCY,
|
|
PROP_TOLERANCE,
|
|
PROP_PLC
|
|
};
|
|
|
|
#define DEFAULT_LATENCY 0
|
|
#define DEFAULT_TOLERANCE 0
|
|
#define DEFAULT_PLC FALSE
|
|
#define DEFAULT_DRAINABLE TRUE
|
|
#define DEFAULT_NEEDS_FORMAT FALSE
|
|
|
|
typedef struct _GstAudioDecoderContext
|
|
{
|
|
/* last negotiated input caps */
|
|
GstCaps *input_caps;
|
|
|
|
/* (output) audio format */
|
|
GstAudioInfo info;
|
|
gboolean output_format_changed;
|
|
|
|
/* parsing state */
|
|
gboolean eos;
|
|
gboolean sync;
|
|
|
|
gboolean had_output_data;
|
|
gboolean had_input_data;
|
|
|
|
/* misc */
|
|
gint delay;
|
|
|
|
/* output */
|
|
gboolean do_plc;
|
|
gboolean do_estimate_rate;
|
|
gint max_errors;
|
|
GstCaps *allocation_caps;
|
|
/* MT-protected (with LOCK) */
|
|
GstClockTime min_latency;
|
|
GstClockTime max_latency;
|
|
|
|
GstAllocator *allocator;
|
|
GstAllocationParams params;
|
|
} GstAudioDecoderContext;
|
|
|
|
struct _GstAudioDecoderPrivate
|
|
{
|
|
/* activation status */
|
|
gboolean active;
|
|
|
|
/* input base/first ts as basis for output ts */
|
|
GstClockTime base_ts;
|
|
/* input samples processed and sent downstream so far (w.r.t. base_ts) */
|
|
guint64 samples;
|
|
|
|
/* collected input data */
|
|
GstAdapter *adapter;
|
|
/* tracking input ts for changes */
|
|
GstClockTime prev_ts;
|
|
guint64 prev_distance;
|
|
/* frames obtained from input */
|
|
GQueue frames;
|
|
/* collected output data */
|
|
GstAdapter *adapter_out;
|
|
/* ts and duration for output data collected above */
|
|
GstClockTime out_ts, out_dur;
|
|
/* mark outgoing discont */
|
|
gboolean discont;
|
|
|
|
/* subclass gave all it could already */
|
|
gboolean drained;
|
|
/* subclass currently being forcibly drained */
|
|
gboolean force;
|
|
/* input_segment are output_segment identical */
|
|
gboolean in_out_segment_sync;
|
|
/* expecting the buffer with DISCONT flag */
|
|
gboolean expecting_discont_buf;
|
|
|
|
|
|
/* input bps estimatation */
|
|
/* global in bytes seen */
|
|
guint64 bytes_in;
|
|
/* global samples sent out */
|
|
guint64 samples_out;
|
|
/* bytes flushed during parsing */
|
|
guint sync_flush;
|
|
/* error count */
|
|
gint error_count;
|
|
|
|
/* upstream stream tags (global tags are passed through as-is) */
|
|
GstTagList *upstream_tags;
|
|
|
|
/* subclass tags */
|
|
GstTagList *taglist; /* FIXME: rename to decoder_tags */
|
|
GstTagMergeMode decoder_tags_merge_mode;
|
|
|
|
gboolean taglist_changed; /* FIXME: rename to tags_changed */
|
|
|
|
/* whether circumstances allow output aggregation */
|
|
gint agg;
|
|
|
|
/* reverse playback queues */
|
|
/* collect input */
|
|
GList *gather;
|
|
/* to-be-decoded */
|
|
GList *decode;
|
|
/* reversed output */
|
|
GList *queued;
|
|
|
|
/* context storage */
|
|
GstAudioDecoderContext ctx;
|
|
|
|
/* properties */
|
|
GstClockTime latency;
|
|
GstClockTime tolerance;
|
|
gboolean plc;
|
|
gboolean drainable;
|
|
gboolean needs_format;
|
|
|
|
/* pending serialized sink events, will be sent from finish_frame() */
|
|
GList *pending_events;
|
|
|
|
/* flags */
|
|
gboolean use_default_pad_acceptcaps;
|
|
};
|
|
|
|
static void gst_audio_decoder_finalize (GObject * object);
|
|
static void gst_audio_decoder_set_property (GObject * object,
|
|
guint prop_id, const GValue * value, GParamSpec * pspec);
|
|
static void gst_audio_decoder_get_property (GObject * object,
|
|
guint prop_id, GValue * value, GParamSpec * pspec);
|
|
|
|
static void gst_audio_decoder_clear_queues (GstAudioDecoder * dec);
|
|
static GstFlowReturn gst_audio_decoder_chain_reverse (GstAudioDecoder *
|
|
dec, GstBuffer * buf);
|
|
|
|
static GstStateChangeReturn gst_audio_decoder_change_state (GstElement *
|
|
element, GstStateChange transition);
|
|
static gboolean gst_audio_decoder_sink_eventfunc (GstAudioDecoder * dec,
|
|
GstEvent * event);
|
|
static gboolean gst_audio_decoder_src_eventfunc (GstAudioDecoder * dec,
|
|
GstEvent * event);
|
|
static gboolean gst_audio_decoder_sink_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event);
|
|
static gboolean gst_audio_decoder_src_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event);
|
|
static gboolean gst_audio_decoder_sink_setcaps (GstAudioDecoder * dec,
|
|
GstCaps * caps);
|
|
static GstFlowReturn gst_audio_decoder_chain (GstPad * pad, GstObject * parent,
|
|
GstBuffer * buf);
|
|
static gboolean gst_audio_decoder_src_query (GstPad * pad, GstObject * parent,
|
|
GstQuery * query);
|
|
static gboolean gst_audio_decoder_sink_query (GstPad * pad, GstObject * parent,
|
|
GstQuery * query);
|
|
static void gst_audio_decoder_reset (GstAudioDecoder * dec, gboolean full);
|
|
|
|
static gboolean gst_audio_decoder_decide_allocation_default (GstAudioDecoder *
|
|
dec, GstQuery * query);
|
|
static gboolean gst_audio_decoder_propose_allocation_default (GstAudioDecoder *
|
|
dec, GstQuery * query);
|
|
static gboolean gst_audio_decoder_negotiate_default (GstAudioDecoder * dec);
|
|
static gboolean gst_audio_decoder_negotiate_unlocked (GstAudioDecoder * dec);
|
|
static gboolean gst_audio_decoder_handle_gap (GstAudioDecoder * dec,
|
|
GstEvent * event);
|
|
static gboolean gst_audio_decoder_sink_query_default (GstAudioDecoder * dec,
|
|
GstQuery * query);
|
|
static gboolean gst_audio_decoder_src_query_default (GstAudioDecoder * dec,
|
|
GstQuery * query);
|
|
|
|
static gboolean gst_audio_decoder_transform_meta_default (GstAudioDecoder *
|
|
decoder, GstBuffer * outbuf, GstMeta * meta, GstBuffer * inbuf);
|
|
|
|
static GstElementClass *parent_class = NULL;
|
|
|
|
static void gst_audio_decoder_class_init (GstAudioDecoderClass * klass);
|
|
static void gst_audio_decoder_init (GstAudioDecoder * dec,
|
|
GstAudioDecoderClass * klass);
|
|
|
|
GType
|
|
gst_audio_decoder_get_type (void)
|
|
{
|
|
static volatile gsize audio_decoder_type = 0;
|
|
|
|
if (g_once_init_enter (&audio_decoder_type)) {
|
|
GType _type;
|
|
static const GTypeInfo audio_decoder_info = {
|
|
sizeof (GstAudioDecoderClass),
|
|
NULL,
|
|
NULL,
|
|
(GClassInitFunc) gst_audio_decoder_class_init,
|
|
NULL,
|
|
NULL,
|
|
sizeof (GstAudioDecoder),
|
|
0,
|
|
(GInstanceInitFunc) gst_audio_decoder_init,
|
|
};
|
|
|
|
_type = g_type_register_static (GST_TYPE_ELEMENT,
|
|
"GstAudioDecoder", &audio_decoder_info, G_TYPE_FLAG_ABSTRACT);
|
|
g_once_init_leave (&audio_decoder_type, _type);
|
|
}
|
|
return audio_decoder_type;
|
|
}
|
|
|
|
|
|
static void
|
|
gst_audio_decoder_class_init (GstAudioDecoderClass * klass)
|
|
{
|
|
GObjectClass *gobject_class;
|
|
GstElementClass *element_class;
|
|
GstAudioDecoderClass *audiodecoder_class;
|
|
|
|
gobject_class = G_OBJECT_CLASS (klass);
|
|
element_class = GST_ELEMENT_CLASS (klass);
|
|
audiodecoder_class = GST_AUDIO_DECODER_CLASS (klass);
|
|
|
|
parent_class = g_type_class_peek_parent (klass);
|
|
|
|
g_type_class_add_private (klass, sizeof (GstAudioDecoderPrivate));
|
|
|
|
GST_DEBUG_CATEGORY_INIT (audiodecoder_debug, "audiodecoder", 0,
|
|
"audio decoder base class");
|
|
|
|
gobject_class->set_property = gst_audio_decoder_set_property;
|
|
gobject_class->get_property = gst_audio_decoder_get_property;
|
|
gobject_class->finalize = gst_audio_decoder_finalize;
|
|
|
|
element_class->change_state =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_change_state);
|
|
|
|
/* Properties */
|
|
g_object_class_install_property (gobject_class, PROP_LATENCY,
|
|
g_param_spec_int64 ("min-latency", "Minimum Latency",
|
|
"Aggregate output data to a minimum of latency time (ns)",
|
|
0, G_MAXINT64, DEFAULT_LATENCY,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, PROP_TOLERANCE,
|
|
g_param_spec_int64 ("tolerance", "Tolerance",
|
|
"Perfect ts while timestamp jitter/imperfection within tolerance (ns)",
|
|
0, G_MAXINT64, DEFAULT_TOLERANCE,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, PROP_PLC,
|
|
g_param_spec_boolean ("plc", "Packet Loss Concealment",
|
|
"Perform packet loss concealment (if supported)",
|
|
DEFAULT_PLC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
audiodecoder_class->sink_event =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_sink_eventfunc);
|
|
audiodecoder_class->src_event =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_src_eventfunc);
|
|
audiodecoder_class->propose_allocation =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_propose_allocation_default);
|
|
audiodecoder_class->decide_allocation =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_decide_allocation_default);
|
|
audiodecoder_class->negotiate =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_negotiate_default);
|
|
audiodecoder_class->sink_query =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_sink_query_default);
|
|
audiodecoder_class->src_query =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_src_query_default);
|
|
audiodecoder_class->transform_meta =
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_transform_meta_default);
|
|
}
|
|
|
|
static void
|
|
gst_audio_decoder_init (GstAudioDecoder * dec, GstAudioDecoderClass * klass)
|
|
{
|
|
GstPadTemplate *pad_template;
|
|
|
|
GST_DEBUG_OBJECT (dec, "gst_audio_decoder_init");
|
|
|
|
dec->priv = GST_AUDIO_DECODER_GET_PRIVATE (dec);
|
|
|
|
/* Setup sink pad */
|
|
pad_template =
|
|
gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "sink");
|
|
g_return_if_fail (pad_template != NULL);
|
|
|
|
dec->sinkpad = gst_pad_new_from_template (pad_template, "sink");
|
|
gst_pad_set_event_function (dec->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_sink_event));
|
|
gst_pad_set_chain_function (dec->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_chain));
|
|
gst_pad_set_query_function (dec->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_sink_query));
|
|
gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad);
|
|
GST_DEBUG_OBJECT (dec, "sinkpad created");
|
|
|
|
/* Setup source pad */
|
|
pad_template =
|
|
gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "src");
|
|
g_return_if_fail (pad_template != NULL);
|
|
|
|
dec->srcpad = gst_pad_new_from_template (pad_template, "src");
|
|
gst_pad_set_event_function (dec->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_src_event));
|
|
gst_pad_set_query_function (dec->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_audio_decoder_src_query));
|
|
gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad);
|
|
GST_DEBUG_OBJECT (dec, "srcpad created");
|
|
|
|
dec->priv->adapter = gst_adapter_new ();
|
|
dec->priv->adapter_out = gst_adapter_new ();
|
|
g_queue_init (&dec->priv->frames);
|
|
|
|
g_rec_mutex_init (&dec->stream_lock);
|
|
|
|
/* property default */
|
|
dec->priv->latency = DEFAULT_LATENCY;
|
|
dec->priv->tolerance = DEFAULT_TOLERANCE;
|
|
dec->priv->plc = DEFAULT_PLC;
|
|
dec->priv->drainable = DEFAULT_DRAINABLE;
|
|
dec->priv->needs_format = DEFAULT_NEEDS_FORMAT;
|
|
|
|
/* init state */
|
|
dec->priv->ctx.min_latency = 0;
|
|
dec->priv->ctx.max_latency = 0;
|
|
gst_audio_decoder_reset (dec, TRUE);
|
|
GST_DEBUG_OBJECT (dec, "init ok");
|
|
}
|
|
|
|
static void
|
|
gst_audio_decoder_reset (GstAudioDecoder * dec, gboolean full)
|
|
{
|
|
GST_DEBUG_OBJECT (dec, "gst_audio_decoder_reset");
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
|
|
if (full) {
|
|
dec->priv->active = FALSE;
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->bytes_in = 0;
|
|
dec->priv->samples_out = 0;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
dec->priv->agg = -1;
|
|
dec->priv->error_count = 0;
|
|
gst_audio_decoder_clear_queues (dec);
|
|
|
|
if (dec->priv->taglist) {
|
|
gst_tag_list_unref (dec->priv->taglist);
|
|
dec->priv->taglist = NULL;
|
|
}
|
|
dec->priv->decoder_tags_merge_mode = GST_TAG_MERGE_KEEP_ALL;
|
|
if (dec->priv->upstream_tags) {
|
|
gst_tag_list_unref (dec->priv->upstream_tags);
|
|
dec->priv->upstream_tags = NULL;
|
|
}
|
|
dec->priv->taglist_changed = FALSE;
|
|
|
|
gst_segment_init (&dec->input_segment, GST_FORMAT_TIME);
|
|
gst_segment_init (&dec->output_segment, GST_FORMAT_TIME);
|
|
dec->priv->in_out_segment_sync = TRUE;
|
|
|
|
g_list_foreach (dec->priv->pending_events, (GFunc) gst_event_unref, NULL);
|
|
g_list_free (dec->priv->pending_events);
|
|
dec->priv->pending_events = NULL;
|
|
|
|
if (dec->priv->ctx.allocator)
|
|
gst_object_unref (dec->priv->ctx.allocator);
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
gst_caps_replace (&dec->priv->ctx.input_caps, NULL);
|
|
gst_caps_replace (&dec->priv->ctx.allocation_caps, NULL);
|
|
|
|
memset (&dec->priv->ctx, 0, sizeof (dec->priv->ctx));
|
|
|
|
gst_audio_info_init (&dec->priv->ctx.info);
|
|
GST_OBJECT_UNLOCK (dec);
|
|
dec->priv->ctx.max_errors = GST_AUDIO_DECODER_MAX_ERRORS;
|
|
dec->priv->ctx.had_output_data = FALSE;
|
|
dec->priv->ctx.had_input_data = FALSE;
|
|
}
|
|
|
|
g_queue_foreach (&dec->priv->frames, (GFunc) gst_buffer_unref, NULL);
|
|
g_queue_clear (&dec->priv->frames);
|
|
gst_adapter_clear (dec->priv->adapter);
|
|
gst_adapter_clear (dec->priv->adapter_out);
|
|
dec->priv->out_ts = GST_CLOCK_TIME_NONE;
|
|
dec->priv->out_dur = 0;
|
|
dec->priv->prev_ts = GST_CLOCK_TIME_NONE;
|
|
dec->priv->prev_distance = 0;
|
|
dec->priv->drained = TRUE;
|
|
dec->priv->base_ts = GST_CLOCK_TIME_NONE;
|
|
dec->priv->samples = 0;
|
|
dec->priv->discont = TRUE;
|
|
dec->priv->sync_flush = FALSE;
|
|
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
}
|
|
|
|
static void
|
|
gst_audio_decoder_finalize (GObject * object)
|
|
{
|
|
GstAudioDecoder *dec;
|
|
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (object));
|
|
dec = GST_AUDIO_DECODER (object);
|
|
|
|
if (dec->priv->adapter) {
|
|
g_object_unref (dec->priv->adapter);
|
|
}
|
|
if (dec->priv->adapter_out) {
|
|
g_object_unref (dec->priv->adapter_out);
|
|
}
|
|
|
|
g_rec_mutex_clear (&dec->stream_lock);
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
static GstEvent *
|
|
gst_audio_decoder_create_merged_tags_event (GstAudioDecoder * dec)
|
|
{
|
|
GstTagList *merged_tags;
|
|
|
|
GST_LOG_OBJECT (dec, "upstream : %" GST_PTR_FORMAT, dec->priv->upstream_tags);
|
|
GST_LOG_OBJECT (dec, "decoder : %" GST_PTR_FORMAT, dec->priv->taglist);
|
|
GST_LOG_OBJECT (dec, "mode : %d", dec->priv->decoder_tags_merge_mode);
|
|
|
|
merged_tags =
|
|
gst_tag_list_merge (dec->priv->upstream_tags,
|
|
dec->priv->taglist, dec->priv->decoder_tags_merge_mode);
|
|
|
|
GST_DEBUG_OBJECT (dec, "merged : %" GST_PTR_FORMAT, merged_tags);
|
|
|
|
if (merged_tags == NULL)
|
|
return NULL;
|
|
|
|
if (gst_tag_list_is_empty (merged_tags)) {
|
|
gst_tag_list_unref (merged_tags);
|
|
return NULL;
|
|
}
|
|
|
|
return gst_event_new_tag (merged_tags);
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_push_event (GstAudioDecoder * dec, GstEvent * event)
|
|
{
|
|
switch (GST_EVENT_TYPE (event)) {
|
|
case GST_EVENT_SEGMENT:{
|
|
GstSegment seg;
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
gst_event_copy_segment (event, &seg);
|
|
|
|
GST_DEBUG_OBJECT (dec, "starting segment %" GST_SEGMENT_FORMAT, &seg);
|
|
|
|
dec->output_segment = seg;
|
|
dec->priv->in_out_segment_sync =
|
|
gst_segment_is_equal (&dec->input_segment, &seg);
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return gst_pad_push_event (dec->srcpad, event);
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_negotiate_default (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
gboolean res = TRUE;
|
|
GstCaps *caps;
|
|
GstCaps *prevcaps;
|
|
GstQuery *query = NULL;
|
|
GstAllocator *allocator;
|
|
GstAllocationParams params;
|
|
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), FALSE);
|
|
g_return_val_if_fail (GST_AUDIO_INFO_IS_VALID (&dec->priv->ctx.info), FALSE);
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
caps = gst_audio_info_to_caps (&dec->priv->ctx.info);
|
|
if (dec->priv->ctx.allocation_caps == NULL)
|
|
dec->priv->ctx.allocation_caps = gst_caps_ref (caps);
|
|
|
|
GST_DEBUG_OBJECT (dec, "setting src caps %" GST_PTR_FORMAT, caps);
|
|
|
|
if (dec->priv->pending_events) {
|
|
GList **pending_events, *l;
|
|
|
|
pending_events = &dec->priv->pending_events;
|
|
|
|
GST_DEBUG_OBJECT (dec, "Pushing pending events");
|
|
for (l = *pending_events; l;) {
|
|
GstEvent *event = GST_EVENT (l->data);
|
|
GList *tmp;
|
|
|
|
if (GST_EVENT_TYPE (event) < GST_EVENT_CAPS) {
|
|
gst_audio_decoder_push_event (dec, l->data);
|
|
tmp = l;
|
|
l = l->next;
|
|
*pending_events = g_list_delete_link (*pending_events, tmp);
|
|
} else {
|
|
l = l->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
prevcaps = gst_pad_get_current_caps (dec->srcpad);
|
|
if (!prevcaps || !gst_caps_is_equal (prevcaps, caps))
|
|
res = gst_pad_set_caps (dec->srcpad, caps);
|
|
if (prevcaps)
|
|
gst_caps_unref (prevcaps);
|
|
|
|
if (!res)
|
|
goto done;
|
|
dec->priv->ctx.output_format_changed = FALSE;
|
|
|
|
query = gst_query_new_allocation (dec->priv->ctx.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,
|
|
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, ¶ms);
|
|
} else {
|
|
allocator = NULL;
|
|
gst_allocation_params_init (¶ms);
|
|
}
|
|
|
|
if (dec->priv->ctx.allocator)
|
|
gst_object_unref (dec->priv->ctx.allocator);
|
|
dec->priv->ctx.allocator = allocator;
|
|
dec->priv->ctx.params = params;
|
|
|
|
done:
|
|
|
|
if (query)
|
|
gst_query_unref (query);
|
|
gst_caps_unref (caps);
|
|
|
|
return res;
|
|
|
|
/* ERRORS */
|
|
no_decide_allocation:
|
|
{
|
|
GST_WARNING_OBJECT (dec, "Subclass failed to decide allocation");
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_negotiate_unlocked (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderClass *klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
gboolean ret = TRUE;
|
|
|
|
if (G_LIKELY (klass->negotiate))
|
|
ret = klass->negotiate (dec);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_negotiate:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Negotiate with downstream elements to currently configured #GstAudioInfo.
|
|
* Unmark GST_PAD_FLAG_NEED_RECONFIGURE in any case. But mark it again if
|
|
* negotiate fails.
|
|
*
|
|
* Returns: %TRUE if the negotiation succeeded, else %FALSE.
|
|
*/
|
|
gboolean
|
|
gst_audio_decoder_negotiate (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
gboolean res = TRUE;
|
|
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), FALSE);
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
gst_pad_check_reconfigure (dec->srcpad);
|
|
if (klass->negotiate) {
|
|
res = klass->negotiate (dec);
|
|
if (!res)
|
|
gst_pad_mark_reconfigure (dec->srcpad);
|
|
}
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_output_format:
|
|
* @dec: a #GstAudioDecoder
|
|
* @info: #GstAudioInfo
|
|
*
|
|
* Configure output info on the srcpad of @dec.
|
|
*
|
|
* Returns: %TRUE on success.
|
|
**/
|
|
gboolean
|
|
gst_audio_decoder_set_output_format (GstAudioDecoder * dec,
|
|
const GstAudioInfo * info)
|
|
{
|
|
gboolean res = TRUE;
|
|
guint old_rate;
|
|
GstCaps *caps = NULL;
|
|
GstCaps *templ_caps;
|
|
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), FALSE);
|
|
g_return_val_if_fail (GST_AUDIO_INFO_IS_VALID (info), FALSE);
|
|
|
|
GST_DEBUG_OBJECT (dec, "Setting output format");
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
|
|
/* If the audio info can't be converted to caps,
|
|
* it was invalid */
|
|
caps = gst_audio_info_to_caps (info);
|
|
if (!caps)
|
|
goto refuse_caps;
|
|
|
|
/* Only allow caps that are a subset of the template caps */
|
|
templ_caps = gst_pad_get_pad_template_caps (dec->srcpad);
|
|
if (!gst_caps_is_subset (caps, templ_caps)) {
|
|
GST_WARNING_OBJECT (dec, "Requested output format %" GST_PTR_FORMAT
|
|
" do not match template %" GST_PTR_FORMAT, caps, templ_caps);
|
|
gst_caps_unref (templ_caps);
|
|
goto refuse_caps;
|
|
}
|
|
gst_caps_unref (templ_caps);
|
|
|
|
/* adjust ts tracking to new sample rate */
|
|
old_rate = GST_AUDIO_INFO_RATE (&dec->priv->ctx.info);
|
|
if (GST_CLOCK_TIME_IS_VALID (dec->priv->base_ts) && old_rate) {
|
|
dec->priv->base_ts +=
|
|
GST_FRAMES_TO_CLOCK_TIME (dec->priv->samples, old_rate);
|
|
dec->priv->samples = 0;
|
|
}
|
|
|
|
/* copy the GstAudioInfo */
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->ctx.info = *info;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
dec->priv->ctx.output_format_changed = TRUE;
|
|
|
|
done:
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
if (caps)
|
|
gst_caps_unref (caps);
|
|
|
|
return res;
|
|
|
|
/* ERRORS */
|
|
refuse_caps:
|
|
{
|
|
GST_WARNING_OBJECT (dec, "invalid output format");
|
|
res = FALSE;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_sink_setcaps (GstAudioDecoder * dec, GstCaps * caps)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
gboolean res = TRUE;
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
GST_DEBUG_OBJECT (dec, "caps: %" GST_PTR_FORMAT, caps);
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
|
|
if (dec->priv->ctx.input_caps
|
|
&& gst_caps_is_equal (dec->priv->ctx.input_caps, caps)) {
|
|
GST_DEBUG_OBJECT (dec, "Caps did not change, not setting again");
|
|
goto done;
|
|
}
|
|
|
|
/* NOTE pbutils only needed here */
|
|
/* TODO maybe (only) upstream demuxer/parser etc should handle this ? */
|
|
#if 0
|
|
if (!dec->priv->taglist)
|
|
dec->priv->taglist = gst_tag_list_new ();
|
|
dec->priv->taglist = gst_tag_list_make_writable (dec->priv->taglist);
|
|
gst_pb_utils_add_codec_description_to_tag_list (dec->priv->taglist,
|
|
GST_TAG_AUDIO_CODEC, caps);
|
|
dec->priv->taglist_changed = TRUE;
|
|
#endif
|
|
|
|
if (klass->set_format)
|
|
res = klass->set_format (dec, caps);
|
|
|
|
if (res)
|
|
gst_caps_replace (&dec->priv->ctx.input_caps, caps);
|
|
|
|
done:
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
gst_audio_decoder_setup (GstAudioDecoder * dec)
|
|
{
|
|
GstQuery *query;
|
|
gboolean res;
|
|
|
|
/* check if in live pipeline, then latency messing is no-no */
|
|
query = gst_query_new_latency ();
|
|
res = gst_pad_peer_query (dec->sinkpad, query);
|
|
if (res) {
|
|
gst_query_parse_latency (query, &res, NULL, NULL);
|
|
res = !res;
|
|
}
|
|
gst_query_unref (query);
|
|
|
|
/* normalize to bool */
|
|
dec->priv->agg = ! !res;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_audio_decoder_push_forward (GstAudioDecoder * dec, GstBuffer * buf)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
GstAudioDecoderPrivate *priv;
|
|
GstAudioDecoderContext *ctx;
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
GstClockTime ts;
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
priv = dec->priv;
|
|
ctx = &dec->priv->ctx;
|
|
|
|
g_return_val_if_fail (ctx->info.bpf != 0, GST_FLOW_ERROR);
|
|
|
|
if (G_UNLIKELY (!buf)) {
|
|
g_assert_not_reached ();
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
ctx->had_output_data = TRUE;
|
|
ts = GST_BUFFER_TIMESTAMP (buf);
|
|
|
|
GST_LOG_OBJECT (dec,
|
|
"clipping buffer of size %" G_GSIZE_FORMAT " with ts %" GST_TIME_FORMAT
|
|
", duration %" GST_TIME_FORMAT, gst_buffer_get_size (buf),
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
|
|
GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
|
|
|
|
/* clip buffer */
|
|
buf = gst_audio_buffer_clip (buf, &dec->output_segment, ctx->info.rate,
|
|
ctx->info.bpf);
|
|
if (G_UNLIKELY (!buf)) {
|
|
GST_DEBUG_OBJECT (dec, "no data after clipping to segment");
|
|
/* only check and return EOS if upstream still
|
|
* in the same segment and interested as such */
|
|
if (dec->priv->in_out_segment_sync) {
|
|
if (dec->output_segment.rate >= 0) {
|
|
if (ts >= dec->output_segment.stop)
|
|
ret = GST_FLOW_EOS;
|
|
} else if (ts < dec->output_segment.start) {
|
|
ret = GST_FLOW_EOS;
|
|
}
|
|
}
|
|
goto exit;
|
|
}
|
|
|
|
/* decorate */
|
|
if (G_UNLIKELY (priv->discont)) {
|
|
GST_LOG_OBJECT (dec, "marking discont");
|
|
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
|
|
priv->discont = FALSE;
|
|
}
|
|
|
|
/* track where we are */
|
|
if (G_LIKELY (GST_BUFFER_TIMESTAMP_IS_VALID (buf))) {
|
|
/* duration should always be valid for raw audio */
|
|
g_assert (GST_BUFFER_DURATION_IS_VALID (buf));
|
|
dec->output_segment.position =
|
|
GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf);
|
|
}
|
|
|
|
if (klass->pre_push) {
|
|
/* last chance for subclass to do some dirty stuff */
|
|
ret = klass->pre_push (dec, &buf);
|
|
if (ret != GST_FLOW_OK || !buf) {
|
|
GST_DEBUG_OBJECT (dec, "subclass returned %s, buf %p",
|
|
gst_flow_get_name (ret), buf);
|
|
if (buf)
|
|
gst_buffer_unref (buf);
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
GST_LOG_OBJECT (dec,
|
|
"pushing buffer of size %" G_GSIZE_FORMAT " with ts %" GST_TIME_FORMAT
|
|
", duration %" GST_TIME_FORMAT, gst_buffer_get_size (buf),
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
|
|
GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
|
|
|
|
ret = gst_pad_push (dec->srcpad, buf);
|
|
|
|
exit:
|
|
return ret;
|
|
}
|
|
|
|
/* mini aggregator combining output buffers into fewer larger ones,
|
|
* if so allowed/configured */
|
|
static GstFlowReturn
|
|
gst_audio_decoder_output (GstAudioDecoder * dec, GstBuffer * buf)
|
|
{
|
|
GstAudioDecoderPrivate *priv;
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
GstBuffer *inbuf = NULL;
|
|
|
|
priv = dec->priv;
|
|
|
|
if (G_UNLIKELY (priv->agg < 0))
|
|
gst_audio_decoder_setup (dec);
|
|
|
|
if (G_LIKELY (buf)) {
|
|
GST_LOG_OBJECT (dec,
|
|
"output buffer of size %" G_GSIZE_FORMAT " with ts %" GST_TIME_FORMAT
|
|
", duration %" GST_TIME_FORMAT, gst_buffer_get_size (buf),
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
|
|
GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
|
|
}
|
|
|
|
again:
|
|
inbuf = NULL;
|
|
if (priv->agg && dec->priv->latency > 0) {
|
|
gint av;
|
|
gboolean assemble = FALSE;
|
|
const GstClockTimeDiff tol = 10 * GST_MSECOND;
|
|
GstClockTimeDiff diff = -100 * GST_MSECOND;
|
|
|
|
av = gst_adapter_available (priv->adapter_out);
|
|
if (G_UNLIKELY (!buf)) {
|
|
/* forcibly send current */
|
|
assemble = TRUE;
|
|
GST_LOG_OBJECT (dec, "forcing fragment flush");
|
|
} else if (av && (!GST_BUFFER_TIMESTAMP_IS_VALID (buf) ||
|
|
!GST_CLOCK_TIME_IS_VALID (priv->out_ts) ||
|
|
((diff = GST_CLOCK_DIFF (GST_BUFFER_TIMESTAMP (buf),
|
|
priv->out_ts + priv->out_dur)) > tol) || diff < -tol)) {
|
|
assemble = TRUE;
|
|
GST_LOG_OBJECT (dec, "buffer %d ms apart from current fragment",
|
|
(gint) (diff / GST_MSECOND));
|
|
} else {
|
|
/* add or start collecting */
|
|
if (!av) {
|
|
GST_LOG_OBJECT (dec, "starting new fragment");
|
|
priv->out_ts = GST_BUFFER_TIMESTAMP (buf);
|
|
} else {
|
|
GST_LOG_OBJECT (dec, "adding to fragment");
|
|
}
|
|
gst_adapter_push (priv->adapter_out, buf);
|
|
priv->out_dur += GST_BUFFER_DURATION (buf);
|
|
av += gst_buffer_get_size (buf);
|
|
buf = NULL;
|
|
}
|
|
if (priv->out_dur > dec->priv->latency)
|
|
assemble = TRUE;
|
|
if (av && assemble) {
|
|
GST_LOG_OBJECT (dec, "assembling fragment");
|
|
inbuf = buf;
|
|
buf = gst_adapter_take_buffer (priv->adapter_out, av);
|
|
GST_BUFFER_TIMESTAMP (buf) = priv->out_ts;
|
|
GST_BUFFER_DURATION (buf) = priv->out_dur;
|
|
priv->out_ts = GST_CLOCK_TIME_NONE;
|
|
priv->out_dur = 0;
|
|
}
|
|
}
|
|
|
|
if (G_LIKELY (buf)) {
|
|
if (dec->output_segment.rate > 0.0) {
|
|
ret = gst_audio_decoder_push_forward (dec, buf);
|
|
GST_LOG_OBJECT (dec, "buffer pushed: %s", gst_flow_get_name (ret));
|
|
} else {
|
|
ret = GST_FLOW_OK;
|
|
priv->queued = g_list_prepend (priv->queued, buf);
|
|
GST_LOG_OBJECT (dec, "buffer queued");
|
|
}
|
|
|
|
if (inbuf) {
|
|
buf = inbuf;
|
|
goto again;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
send_pending_events (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderPrivate *priv = dec->priv;
|
|
GList *pending_events, *l;
|
|
|
|
pending_events = priv->pending_events;
|
|
priv->pending_events = NULL;
|
|
|
|
GST_DEBUG_OBJECT (dec, "Pushing pending events");
|
|
for (l = pending_events; l; l = l->next)
|
|
gst_audio_decoder_push_event (dec, l->data);
|
|
g_list_free (pending_events);
|
|
}
|
|
|
|
/* Iterate the list of pending events, and ensure
|
|
* the current output segment is up to date for
|
|
* decoding */
|
|
static void
|
|
apply_pending_events (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderPrivate *priv = dec->priv;
|
|
GList *l;
|
|
|
|
GST_DEBUG_OBJECT (dec, "Applying pending segments");
|
|
for (l = priv->pending_events; l; l = l->next) {
|
|
GstEvent *event = GST_EVENT (l->data);
|
|
switch (GST_EVENT_TYPE (event)) {
|
|
case GST_EVENT_SEGMENT:{
|
|
GstSegment seg;
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
gst_event_copy_segment (event, &seg);
|
|
|
|
GST_DEBUG_OBJECT (dec, "starting segment %" GST_SEGMENT_FORMAT, &seg);
|
|
|
|
dec->output_segment = seg;
|
|
dec->priv->in_out_segment_sync =
|
|
gst_segment_is_equal (&dec->input_segment, &seg);
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static GstFlowReturn
|
|
check_pending_reconfigure (GstAudioDecoder * dec)
|
|
{
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
GstAudioDecoderContext *ctx;
|
|
gboolean needs_reconfigure;
|
|
|
|
ctx = &dec->priv->ctx;
|
|
|
|
needs_reconfigure = gst_pad_check_reconfigure (dec->srcpad);
|
|
if (G_UNLIKELY (ctx->output_format_changed ||
|
|
(GST_AUDIO_INFO_IS_VALID (&ctx->info)
|
|
&& needs_reconfigure))) {
|
|
if (!gst_audio_decoder_negotiate_unlocked (dec)) {
|
|
gst_pad_mark_reconfigure (dec->srcpad);
|
|
if (GST_PAD_IS_FLUSHING (dec->srcpad))
|
|
ret = GST_FLOW_FLUSHING;
|
|
else
|
|
ret = GST_FLOW_NOT_NEGOTIATED;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_transform_meta_default (GstAudioDecoder *
|
|
decoder, GstBuffer * outbuf, GstMeta * meta, GstBuffer * inbuf)
|
|
{
|
|
const GstMetaInfo *info = meta->info;
|
|
const gchar *const *tags;
|
|
|
|
tags = gst_meta_api_type_get_tags (info->api);
|
|
|
|
if (!tags || (g_strv_length ((gchar **) tags) == 1
|
|
&& gst_meta_api_type_has_tag (info->api,
|
|
g_quark_from_string (GST_META_TAG_AUDIO_STR))))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
GstAudioDecoder *decoder;
|
|
GstBuffer *outbuf;
|
|
} CopyMetaData;
|
|
|
|
static gboolean
|
|
foreach_metadata (GstBuffer * inbuf, GstMeta ** meta, gpointer user_data)
|
|
{
|
|
CopyMetaData *data = user_data;
|
|
GstAudioDecoder *decoder = data->decoder;
|
|
GstAudioDecoderClass *klass = GST_AUDIO_DECODER_GET_CLASS (decoder);
|
|
GstBuffer *outbuf = data->outbuf;
|
|
const GstMetaInfo *info = (*meta)->info;
|
|
gboolean do_copy = FALSE;
|
|
|
|
if (gst_meta_api_type_has_tag (info->api, _gst_meta_tag_memory)) {
|
|
/* never call the transform_meta with memory specific metadata */
|
|
GST_DEBUG_OBJECT (decoder, "not copying memory specific metadata %s",
|
|
g_type_name (info->api));
|
|
do_copy = FALSE;
|
|
} else if (klass->transform_meta) {
|
|
do_copy = klass->transform_meta (decoder, outbuf, *meta, inbuf);
|
|
GST_DEBUG_OBJECT (decoder, "transformed metadata %s: copy: %d",
|
|
g_type_name (info->api), do_copy);
|
|
}
|
|
|
|
/* we only copy metadata when the subclass implemented a transform_meta
|
|
* function and when it returns %TRUE */
|
|
if (do_copy && info->transform_func) {
|
|
GstMetaTransformCopy copy_data = { FALSE, 0, -1 };
|
|
GST_DEBUG_OBJECT (decoder, "copy metadata %s", g_type_name (info->api));
|
|
/* simply copy then */
|
|
info->transform_func (outbuf, *meta, inbuf,
|
|
_gst_meta_transform_copy, ©_data);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_finish_frame:
|
|
* @dec: a #GstAudioDecoder
|
|
* @buf: decoded data
|
|
* @frames: number of decoded frames represented by decoded data
|
|
*
|
|
* Collects decoded data and pushes it downstream.
|
|
*
|
|
* @buf may be NULL in which case the indicated number of frames
|
|
* are discarded and considered to have produced no output
|
|
* (e.g. lead-in or setup frames).
|
|
* Otherwise, source pad caps must be set when it is called with valid
|
|
* data in @buf.
|
|
*
|
|
* Note that a frame received in gst_audio_decoder_handle_frame() may be
|
|
* invalidated by a call to this function.
|
|
*
|
|
* Returns: a #GstFlowReturn that should be escalated to caller (of caller)
|
|
*/
|
|
GstFlowReturn
|
|
gst_audio_decoder_finish_frame (GstAudioDecoder * dec, GstBuffer * buf,
|
|
gint frames)
|
|
{
|
|
GstAudioDecoderPrivate *priv;
|
|
GstAudioDecoderContext *ctx;
|
|
GstAudioDecoderClass *klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
gint samples = 0;
|
|
GstClockTime ts, next_ts;
|
|
gsize size;
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
GQueue inbufs = G_QUEUE_INIT;
|
|
|
|
/* subclass should not hand us no data */
|
|
g_return_val_if_fail (buf == NULL || gst_buffer_get_size (buf) > 0,
|
|
GST_FLOW_ERROR);
|
|
/* no dummy calls please */
|
|
g_return_val_if_fail (frames != 0, GST_FLOW_ERROR);
|
|
|
|
priv = dec->priv;
|
|
ctx = &dec->priv->ctx;
|
|
size = buf ? gst_buffer_get_size (buf) : 0;
|
|
|
|
/* must know the output format by now */
|
|
g_return_val_if_fail (buf == NULL || GST_AUDIO_INFO_IS_VALID (&ctx->info),
|
|
GST_FLOW_ERROR);
|
|
|
|
GST_LOG_OBJECT (dec,
|
|
"accepting %" G_GSIZE_FORMAT " bytes == %" G_GSIZE_FORMAT
|
|
" samples for %d frames", buf ? size : -1,
|
|
buf ? size / ctx->info.bpf : -1, frames);
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
|
|
if (buf) {
|
|
ret = check_pending_reconfigure (dec);
|
|
if (ret == GST_FLOW_FLUSHING || ret == GST_FLOW_NOT_NEGOTIATED) {
|
|
gst_buffer_unref (buf);
|
|
goto exit;
|
|
}
|
|
|
|
if (priv->pending_events)
|
|
send_pending_events (dec);
|
|
}
|
|
|
|
/* output shoud be whole number of sample frames */
|
|
if (G_LIKELY (buf && ctx->info.bpf)) {
|
|
if (size % ctx->info.bpf)
|
|
goto wrong_buffer;
|
|
/* per channel least */
|
|
samples = size / ctx->info.bpf;
|
|
}
|
|
|
|
/* frame and ts book-keeping */
|
|
if (G_UNLIKELY (frames < 0)) {
|
|
if (G_UNLIKELY (-frames - 1 > priv->frames.length)) {
|
|
GST_ELEMENT_WARNING (dec, STREAM, DECODE,
|
|
("received more decoded frames %d than provided %d", frames,
|
|
priv->frames.length), (NULL));
|
|
frames = 0;
|
|
} else {
|
|
frames = priv->frames.length + frames + 1;
|
|
}
|
|
} else if (G_UNLIKELY (frames > priv->frames.length)) {
|
|
if (G_LIKELY (!priv->force)) {
|
|
GST_ELEMENT_WARNING (dec, STREAM, DECODE,
|
|
("received more decoded frames %d than provided %d", frames,
|
|
priv->frames.length), (NULL));
|
|
}
|
|
frames = priv->frames.length;
|
|
}
|
|
|
|
if (G_LIKELY (priv->frames.length))
|
|
ts = GST_BUFFER_TIMESTAMP (priv->frames.head->data);
|
|
else
|
|
ts = GST_CLOCK_TIME_NONE;
|
|
|
|
GST_DEBUG_OBJECT (dec, "leading frame ts %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (ts));
|
|
|
|
while (priv->frames.length && frames) {
|
|
g_queue_push_tail (&inbufs, g_queue_pop_head (&priv->frames));
|
|
dec->priv->ctx.delay = dec->priv->frames.length;
|
|
frames--;
|
|
}
|
|
|
|
if (G_UNLIKELY (!buf))
|
|
goto exit;
|
|
|
|
/* lock on */
|
|
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (priv->base_ts))) {
|
|
priv->base_ts = ts;
|
|
GST_DEBUG_OBJECT (dec, "base_ts now %" GST_TIME_FORMAT, GST_TIME_ARGS (ts));
|
|
}
|
|
|
|
/* still no valid ts, track the segment one */
|
|
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (priv->base_ts)) &&
|
|
dec->output_segment.rate > 0.0) {
|
|
priv->base_ts = dec->output_segment.start;
|
|
}
|
|
|
|
/* slightly convoluted approach caters for perfect ts if subclass desires */
|
|
if (GST_CLOCK_TIME_IS_VALID (ts)) {
|
|
if (dec->priv->tolerance > 0) {
|
|
GstClockTimeDiff diff;
|
|
|
|
g_assert (GST_CLOCK_TIME_IS_VALID (priv->base_ts));
|
|
next_ts = priv->base_ts +
|
|
gst_util_uint64_scale (priv->samples, GST_SECOND, ctx->info.rate);
|
|
GST_LOG_OBJECT (dec,
|
|
"buffer is %" G_GUINT64_FORMAT " samples past base_ts %"
|
|
GST_TIME_FORMAT ", expected ts %" GST_TIME_FORMAT, priv->samples,
|
|
GST_TIME_ARGS (priv->base_ts), GST_TIME_ARGS (next_ts));
|
|
diff = GST_CLOCK_DIFF (next_ts, ts);
|
|
GST_LOG_OBJECT (dec, "ts diff %d ms", (gint) (diff / GST_MSECOND));
|
|
/* if within tolerance,
|
|
* discard buffer ts and carry on producing perfect stream,
|
|
* otherwise resync to ts */
|
|
if (G_UNLIKELY (diff < (gint64) - dec->priv->tolerance ||
|
|
diff > (gint64) dec->priv->tolerance)) {
|
|
GST_DEBUG_OBJECT (dec, "base_ts resync");
|
|
priv->base_ts = ts;
|
|
priv->samples = 0;
|
|
}
|
|
} else {
|
|
GST_DEBUG_OBJECT (dec, "base_ts resync");
|
|
priv->base_ts = ts;
|
|
priv->samples = 0;
|
|
}
|
|
}
|
|
|
|
/* delayed one-shot stuff until confirmed data */
|
|
if (priv->taglist && priv->taglist_changed) {
|
|
GstEvent *tags_event;
|
|
|
|
tags_event = gst_audio_decoder_create_merged_tags_event (dec);
|
|
|
|
if (tags_event != NULL)
|
|
gst_audio_decoder_push_event (dec, tags_event);
|
|
|
|
priv->taglist_changed = FALSE;
|
|
}
|
|
|
|
buf = gst_buffer_make_writable (buf);
|
|
if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (priv->base_ts))) {
|
|
GST_BUFFER_TIMESTAMP (buf) =
|
|
priv->base_ts +
|
|
GST_FRAMES_TO_CLOCK_TIME (priv->samples, ctx->info.rate);
|
|
GST_BUFFER_DURATION (buf) = priv->base_ts +
|
|
GST_FRAMES_TO_CLOCK_TIME (priv->samples + samples, ctx->info.rate) -
|
|
GST_BUFFER_TIMESTAMP (buf);
|
|
} else {
|
|
GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
|
|
GST_BUFFER_DURATION (buf) =
|
|
GST_FRAMES_TO_CLOCK_TIME (samples, ctx->info.rate);
|
|
}
|
|
|
|
if (klass->transform_meta) {
|
|
if (inbufs.length) {
|
|
GList *l;
|
|
for (l = inbufs.head; l; l = l->next) {
|
|
CopyMetaData data;
|
|
|
|
data.decoder = dec;
|
|
data.outbuf = buf;
|
|
gst_buffer_foreach_meta (l->data, foreach_metadata, &data);
|
|
}
|
|
} else {
|
|
GST_WARNING_OBJECT (dec,
|
|
"Can't copy metadata because input buffers disappeared");
|
|
}
|
|
}
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
priv->samples += samples;
|
|
priv->samples_out += samples;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
/* we got data, so note things are looking up */
|
|
if (G_UNLIKELY (dec->priv->error_count))
|
|
dec->priv->error_count = 0;
|
|
|
|
ret = gst_audio_decoder_output (dec, buf);
|
|
|
|
exit:
|
|
g_queue_foreach (&inbufs, (GFunc) gst_buffer_unref, NULL);
|
|
g_queue_clear (&inbufs);
|
|
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
return ret;
|
|
|
|
/* ERRORS */
|
|
wrong_buffer:
|
|
{
|
|
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL),
|
|
("buffer size %" G_GSIZE_FORMAT " not a multiple of %d", size,
|
|
ctx->info.bpf));
|
|
gst_buffer_unref (buf);
|
|
ret = GST_FLOW_ERROR;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_audio_decoder_handle_frame (GstAudioDecoder * dec,
|
|
GstAudioDecoderClass * klass, GstBuffer * buffer)
|
|
{
|
|
/* Skip decoding and send a GAP instead if
|
|
* GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO is set and we have timestamps
|
|
* FIXME: We only do this for forward playback atm, because reverse
|
|
* playback would require accumulating GAP events and pushing them
|
|
* out in reverse order as for normal audio samples
|
|
*/
|
|
if (G_UNLIKELY (dec->input_segment.rate > 0.0
|
|
&& dec->input_segment.flags & GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO)) {
|
|
if (buffer) {
|
|
GstClockTime ts = GST_BUFFER_PTS (buffer);
|
|
if (GST_CLOCK_TIME_IS_VALID (ts)) {
|
|
GstEvent *event = gst_event_new_gap (ts, GST_BUFFER_DURATION (buffer));
|
|
|
|
gst_buffer_unref (buffer);
|
|
GST_LOG_OBJECT (dec, "Skipping decode in trickmode and sending gap");
|
|
gst_audio_decoder_handle_gap (dec, event);
|
|
return GST_FLOW_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (G_LIKELY (buffer)) {
|
|
gsize size = gst_buffer_get_size (buffer);
|
|
/* keep around for admin */
|
|
GST_LOG_OBJECT (dec,
|
|
"tracking frame size %" G_GSIZE_FORMAT ", ts %" GST_TIME_FORMAT, size,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)));
|
|
g_queue_push_tail (&dec->priv->frames, buffer);
|
|
dec->priv->ctx.delay = dec->priv->frames.length;
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->bytes_in += size;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
} else {
|
|
GST_LOG_OBJECT (dec, "providing subclass with NULL frame");
|
|
}
|
|
|
|
return klass->handle_frame (dec, buffer);
|
|
}
|
|
|
|
/* maybe subclass configurable instead, but this allows for a whole lot of
|
|
* raw samples, so at least quite some encoded ... */
|
|
#define GST_AUDIO_DECODER_MAX_SYNC 10 * 8 * 2 * 1024
|
|
|
|
static GstFlowReturn
|
|
gst_audio_decoder_push_buffers (GstAudioDecoder * dec, gboolean force)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
GstAudioDecoderPrivate *priv;
|
|
GstAudioDecoderContext *ctx;
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
GstBuffer *buffer;
|
|
gint av, flush;
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
priv = dec->priv;
|
|
ctx = &dec->priv->ctx;
|
|
|
|
g_return_val_if_fail (klass->handle_frame != NULL, GST_FLOW_ERROR);
|
|
|
|
av = gst_adapter_available (priv->adapter);
|
|
GST_DEBUG_OBJECT (dec, "available: %d", av);
|
|
|
|
while (ret == GST_FLOW_OK) {
|
|
|
|
flush = 0;
|
|
ctx->eos = force;
|
|
|
|
if (G_LIKELY (av)) {
|
|
gint len;
|
|
GstClockTime ts;
|
|
guint64 distance;
|
|
|
|
/* parse if needed */
|
|
if (klass->parse) {
|
|
gint offset = 0;
|
|
|
|
/* limited (legacy) parsing; avoid whole of baseparse */
|
|
GST_DEBUG_OBJECT (dec, "parsing available: %d", av);
|
|
/* piggyback sync state on discont */
|
|
ctx->sync = !priv->discont;
|
|
ret = klass->parse (dec, priv->adapter, &offset, &len);
|
|
|
|
g_assert (offset <= av);
|
|
if (offset) {
|
|
/* jumped a bit */
|
|
GST_DEBUG_OBJECT (dec, "skipped %d; setting DISCONT", offset);
|
|
gst_adapter_flush (priv->adapter, offset);
|
|
flush = offset;
|
|
/* avoid parsing indefinitely */
|
|
priv->sync_flush += offset;
|
|
if (priv->sync_flush > GST_AUDIO_DECODER_MAX_SYNC)
|
|
goto parse_failed;
|
|
}
|
|
|
|
if (ret == GST_FLOW_EOS) {
|
|
GST_LOG_OBJECT (dec, "no frame yet");
|
|
ret = GST_FLOW_OK;
|
|
break;
|
|
} else if (ret == GST_FLOW_OK) {
|
|
GST_LOG_OBJECT (dec, "frame at offset %d of length %d", offset, len);
|
|
g_assert (len);
|
|
g_assert (offset + len <= av);
|
|
priv->sync_flush = 0;
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
len = av;
|
|
}
|
|
/* track upstream ts, but do not get stuck if nothing new upstream */
|
|
ts = gst_adapter_prev_pts (priv->adapter, &distance);
|
|
if (ts != priv->prev_ts || distance <= priv->prev_distance) {
|
|
priv->prev_ts = ts;
|
|
priv->prev_distance = distance;
|
|
} else {
|
|
GST_LOG_OBJECT (dec, "ts == prev_ts; discarding");
|
|
ts = GST_CLOCK_TIME_NONE;
|
|
}
|
|
buffer = gst_adapter_take_buffer (priv->adapter, len);
|
|
buffer = gst_buffer_make_writable (buffer);
|
|
GST_BUFFER_TIMESTAMP (buffer) = ts;
|
|
flush += len;
|
|
priv->force = FALSE;
|
|
} else {
|
|
if (!force)
|
|
break;
|
|
if (!priv->drainable) {
|
|
priv->drained = TRUE;
|
|
break;
|
|
}
|
|
buffer = NULL;
|
|
priv->force = TRUE;
|
|
}
|
|
|
|
ret = gst_audio_decoder_handle_frame (dec, klass, buffer);
|
|
|
|
/* do not keep pushing it ... */
|
|
if (G_UNLIKELY (!av)) {
|
|
priv->drained = TRUE;
|
|
break;
|
|
}
|
|
|
|
av -= flush;
|
|
g_assert (av >= 0);
|
|
}
|
|
|
|
GST_LOG_OBJECT (dec, "done pushing to subclass");
|
|
return ret;
|
|
|
|
/* ERRORS */
|
|
parse_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("failed to parse stream"));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_audio_decoder_drain (GstAudioDecoder * dec)
|
|
{
|
|
GstFlowReturn ret;
|
|
|
|
if (dec->priv->drained && !dec->priv->gather)
|
|
return GST_FLOW_OK;
|
|
|
|
/* Apply any pending events before draining, as that
|
|
* may update the pending segment info */
|
|
apply_pending_events (dec);
|
|
|
|
/* dispatch reverse pending buffers */
|
|
/* chain eventually calls upon drain as well, but by that time
|
|
* gather list should be clear, so ok ... */
|
|
if (dec->output_segment.rate < 0.0 && dec->priv->gather)
|
|
gst_audio_decoder_chain_reverse (dec, NULL);
|
|
/* have subclass give all it can */
|
|
ret = gst_audio_decoder_push_buffers (dec, TRUE);
|
|
if (ret != GST_FLOW_OK) {
|
|
GST_WARNING_OBJECT (dec, "audio decoder push buffers failed");
|
|
goto drain_failed;
|
|
}
|
|
/* ensure all output sent */
|
|
ret = gst_audio_decoder_output (dec, NULL);
|
|
if (ret != GST_FLOW_OK)
|
|
GST_WARNING_OBJECT (dec, "audio decoder output failed");
|
|
|
|
drain_failed:
|
|
/* everything should be away now */
|
|
if (dec->priv->frames.length) {
|
|
/* not fatal/impossible though if subclass/codec eats stuff */
|
|
GST_WARNING_OBJECT (dec, "still %d frames left after draining",
|
|
dec->priv->frames.length);
|
|
g_queue_foreach (&dec->priv->frames, (GFunc) gst_buffer_unref, NULL);
|
|
g_queue_clear (&dec->priv->frames);
|
|
}
|
|
|
|
/* discard (unparsed) leftover */
|
|
gst_adapter_clear (dec->priv->adapter);
|
|
return ret;
|
|
}
|
|
|
|
/* hard == FLUSH, otherwise discont */
|
|
static GstFlowReturn
|
|
gst_audio_decoder_flush (GstAudioDecoder * dec, gboolean hard)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
GST_LOG_OBJECT (dec, "flush hard %d", hard);
|
|
|
|
if (!hard) {
|
|
ret = gst_audio_decoder_drain (dec);
|
|
} else {
|
|
gst_audio_decoder_clear_queues (dec);
|
|
gst_segment_init (&dec->input_segment, GST_FORMAT_TIME);
|
|
gst_segment_init (&dec->output_segment, GST_FORMAT_TIME);
|
|
dec->priv->error_count = 0;
|
|
}
|
|
/* only bother subclass with flushing if known it is already alive
|
|
* and kicking out stuff */
|
|
if (klass->flush && dec->priv->samples_out > 0)
|
|
klass->flush (dec, hard);
|
|
/* and get (re)set for the sequel */
|
|
gst_audio_decoder_reset (dec, FALSE);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_audio_decoder_chain_forward (GstAudioDecoder * dec, GstBuffer * buffer)
|
|
{
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
|
|
/* discard silly case, though maybe ts may be of value ?? */
|
|
if (G_UNLIKELY (gst_buffer_get_size (buffer) == 0)) {
|
|
GST_DEBUG_OBJECT (dec, "discarding empty buffer");
|
|
gst_buffer_unref (buffer);
|
|
goto exit;
|
|
}
|
|
|
|
/* grab buffer */
|
|
gst_adapter_push (dec->priv->adapter, buffer);
|
|
buffer = NULL;
|
|
/* new stuff, so we can push subclass again */
|
|
dec->priv->drained = FALSE;
|
|
|
|
/* hand to subclass */
|
|
ret = gst_audio_decoder_push_buffers (dec, FALSE);
|
|
|
|
exit:
|
|
GST_LOG_OBJECT (dec, "chain-done");
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
gst_audio_decoder_clear_queues (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderPrivate *priv = dec->priv;
|
|
|
|
g_list_foreach (priv->queued, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (priv->queued);
|
|
priv->queued = NULL;
|
|
g_list_foreach (priv->gather, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (priv->gather);
|
|
priv->gather = NULL;
|
|
g_list_foreach (priv->decode, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (priv->decode);
|
|
priv->decode = NULL;
|
|
}
|
|
|
|
/*
|
|
* Input:
|
|
* Buffer decoding order: 7 8 9 4 5 6 3 1 2 EOS
|
|
* Discont flag: D D D D
|
|
*
|
|
* - Each Discont marks a discont in the decoding order.
|
|
*
|
|
* for vorbis, each buffer is a keyframe when we have the previous
|
|
* buffer. This means that to decode buffer 7, we need buffer 6, which
|
|
* arrives out of order.
|
|
*
|
|
* we first gather buffers in the gather queue until we get a DISCONT. We
|
|
* prepend each incomming buffer so that they are in reversed order.
|
|
*
|
|
* gather queue: 9 8 7
|
|
* decode queue:
|
|
* output queue:
|
|
*
|
|
* When a DISCONT is received (buffer 4), we move the gather queue to the
|
|
* decode queue. This is simply done be taking the head of the gather queue
|
|
* and prepending it to the decode queue. This yields:
|
|
*
|
|
* gather queue:
|
|
* decode queue: 7 8 9
|
|
* output queue:
|
|
*
|
|
* Then we decode each buffer in the decode queue in order and put the output
|
|
* buffer in the output queue. The first buffer (7) will not produce any output
|
|
* because it needs the previous buffer (6) which did not arrive yet. This
|
|
* yields:
|
|
*
|
|
* gather queue:
|
|
* decode queue: 7 8 9
|
|
* output queue: 9 8
|
|
*
|
|
* Then we remove the consumed buffers from the decode queue. Buffer 7 is not
|
|
* completely consumed, we need to keep it around for when we receive buffer
|
|
* 6. This yields:
|
|
*
|
|
* gather queue:
|
|
* decode queue: 7
|
|
* output queue: 9 8
|
|
*
|
|
* Then we accumulate more buffers:
|
|
*
|
|
* gather queue: 6 5 4
|
|
* decode queue: 7
|
|
* output queue:
|
|
*
|
|
* prepending to the decode queue on DISCONT yields:
|
|
*
|
|
* gather queue:
|
|
* decode queue: 4 5 6 7
|
|
* output queue:
|
|
*
|
|
* after decoding and keeping buffer 4:
|
|
*
|
|
* gather queue:
|
|
* decode queue: 4
|
|
* output queue: 7 6 5
|
|
*
|
|
* Etc..
|
|
*/
|
|
static GstFlowReturn
|
|
gst_audio_decoder_flush_decode (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderPrivate *priv = dec->priv;
|
|
GstFlowReturn res = GST_FLOW_OK;
|
|
GstClockTime timestamp;
|
|
GList *walk;
|
|
|
|
walk = priv->decode;
|
|
|
|
GST_DEBUG_OBJECT (dec, "flushing buffers to decoder");
|
|
|
|
/* clear buffer and decoder state */
|
|
gst_audio_decoder_flush (dec, FALSE);
|
|
|
|
while (walk) {
|
|
GList *next;
|
|
GstBuffer *buf = GST_BUFFER_CAST (walk->data);
|
|
|
|
GST_DEBUG_OBJECT (dec, "decoding buffer %p, ts %" GST_TIME_FORMAT,
|
|
buf, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
|
|
|
|
next = g_list_next (walk);
|
|
/* decode buffer, resulting data prepended to output queue */
|
|
gst_buffer_ref (buf);
|
|
res = gst_audio_decoder_chain_forward (dec, buf);
|
|
|
|
/* if we generated output, we can discard the buffer, else we
|
|
* keep it in the queue */
|
|
if (priv->queued) {
|
|
GST_DEBUG_OBJECT (dec, "decoded buffer to %p", priv->queued->data);
|
|
priv->decode = g_list_delete_link (priv->decode, walk);
|
|
gst_buffer_unref (buf);
|
|
} else {
|
|
GST_DEBUG_OBJECT (dec, "buffer did not decode, keeping");
|
|
}
|
|
walk = next;
|
|
}
|
|
|
|
/* drain any aggregation (or otherwise) leftover */
|
|
gst_audio_decoder_drain (dec);
|
|
|
|
/* now send queued data downstream */
|
|
timestamp = GST_CLOCK_TIME_NONE;
|
|
while (priv->queued) {
|
|
GstBuffer *buf = GST_BUFFER_CAST (priv->queued->data);
|
|
GstClockTime duration;
|
|
|
|
duration = GST_BUFFER_DURATION (buf);
|
|
|
|
/* duration should always be valid for raw audio */
|
|
g_assert (GST_CLOCK_TIME_IS_VALID (duration));
|
|
|
|
/* interpolate (backward) if needed */
|
|
if (G_LIKELY (timestamp != -1)) {
|
|
if (timestamp > duration)
|
|
timestamp -= duration;
|
|
else
|
|
timestamp = 0;
|
|
}
|
|
|
|
if (!GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
|
|
GST_LOG_OBJECT (dec, "applying reverse interpolated ts %"
|
|
GST_TIME_FORMAT, GST_TIME_ARGS (timestamp));
|
|
GST_BUFFER_TIMESTAMP (buf) = timestamp;
|
|
} else {
|
|
/* track otherwise */
|
|
timestamp = GST_BUFFER_TIMESTAMP (buf);
|
|
GST_LOG_OBJECT (dec, "tracking ts %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (timestamp));
|
|
}
|
|
|
|
if (G_LIKELY (res == GST_FLOW_OK)) {
|
|
GST_DEBUG_OBJECT (dec, "pushing buffer %p of size %" G_GSIZE_FORMAT ", "
|
|
"time %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT, buf,
|
|
gst_buffer_get_size (buf), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
|
|
GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
|
|
/* should be already, but let's be sure */
|
|
buf = gst_buffer_make_writable (buf);
|
|
/* avoid stray DISCONT from forward processing,
|
|
* which have no meaning in reverse pushing */
|
|
GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
|
|
res = gst_audio_decoder_push_forward (dec, buf);
|
|
} else {
|
|
gst_buffer_unref (buf);
|
|
}
|
|
|
|
priv->queued = g_list_delete_link (priv->queued, priv->queued);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_audio_decoder_chain_reverse (GstAudioDecoder * dec, GstBuffer * buf)
|
|
{
|
|
GstAudioDecoderPrivate *priv = dec->priv;
|
|
GstFlowReturn result = GST_FLOW_OK;
|
|
|
|
/* if we have a discont, move buffers to the decode list */
|
|
if (!buf || GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT)) {
|
|
GST_DEBUG_OBJECT (dec, "received discont");
|
|
while (priv->gather) {
|
|
GstBuffer *gbuf;
|
|
|
|
gbuf = GST_BUFFER_CAST (priv->gather->data);
|
|
/* remove from the gather list */
|
|
priv->gather = g_list_delete_link (priv->gather, priv->gather);
|
|
/* copy to decode queue */
|
|
priv->decode = g_list_prepend (priv->decode, gbuf);
|
|
}
|
|
/* decode stuff in the decode queue */
|
|
gst_audio_decoder_flush_decode (dec);
|
|
}
|
|
|
|
if (G_LIKELY (buf)) {
|
|
GST_DEBUG_OBJECT (dec, "gathering buffer %p of size %" G_GSIZE_FORMAT ", "
|
|
"time %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT, buf,
|
|
gst_buffer_get_size (buf), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
|
|
GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
|
|
|
|
/* add buffer to gather queue */
|
|
priv->gather = g_list_prepend (priv->gather, buf);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_audio_decoder_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
|
|
{
|
|
GstAudioDecoder *dec;
|
|
GstFlowReturn ret;
|
|
|
|
dec = GST_AUDIO_DECODER (parent);
|
|
|
|
GST_LOG_OBJECT (dec,
|
|
"received buffer of size %" G_GSIZE_FORMAT " with ts %" GST_TIME_FORMAT
|
|
", duration %" GST_TIME_FORMAT, gst_buffer_get_size (buffer),
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
|
|
GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)));
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
|
|
if (G_UNLIKELY (dec->priv->ctx.input_caps == NULL && dec->priv->needs_format))
|
|
goto not_negotiated;
|
|
|
|
dec->priv->ctx.had_input_data = TRUE;
|
|
|
|
if (!dec->priv->expecting_discont_buf &&
|
|
GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) {
|
|
gint64 samples, ts;
|
|
|
|
/* track present position */
|
|
ts = dec->priv->base_ts;
|
|
samples = dec->priv->samples;
|
|
|
|
GST_DEBUG_OBJECT (dec, "handling discont");
|
|
gst_audio_decoder_flush (dec, FALSE);
|
|
dec->priv->discont = TRUE;
|
|
|
|
/* buffer may claim DISCONT loudly, if it can't tell us where we are now,
|
|
* we'll stick to where we were ...
|
|
* Particularly useful/needed for upstream BYTE based */
|
|
if (dec->input_segment.rate > 0.0
|
|
&& !GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {
|
|
GST_DEBUG_OBJECT (dec, "... but restoring previous ts tracking");
|
|
dec->priv->base_ts = ts;
|
|
dec->priv->samples = samples;
|
|
}
|
|
}
|
|
dec->priv->expecting_discont_buf = FALSE;
|
|
|
|
if (dec->input_segment.rate > 0.0)
|
|
ret = gst_audio_decoder_chain_forward (dec, buffer);
|
|
else
|
|
ret = gst_audio_decoder_chain_reverse (dec, buffer);
|
|
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
return ret;
|
|
|
|
/* ERRORS */
|
|
not_negotiated:
|
|
{
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
GST_ELEMENT_ERROR (dec, CORE, NEGOTIATION, (NULL),
|
|
("decoder not initialized"));
|
|
gst_buffer_unref (buffer);
|
|
return GST_FLOW_NOT_NEGOTIATED;
|
|
}
|
|
}
|
|
|
|
/* perform upstream byte <-> time conversion (duration, seeking)
|
|
* if subclass allows and if enough data for moderately decent conversion */
|
|
static inline gboolean
|
|
gst_audio_decoder_do_byte (GstAudioDecoder * dec)
|
|
{
|
|
gboolean ret;
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
ret = dec->priv->ctx.do_estimate_rate && dec->priv->ctx.info.bpf &&
|
|
dec->priv->ctx.info.rate <= dec->priv->samples_out;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Must be called holding the GST_AUDIO_DECODER_STREAM_LOCK */
|
|
static gboolean
|
|
gst_audio_decoder_negotiate_default_caps (GstAudioDecoder * dec)
|
|
{
|
|
GstCaps *caps, *templcaps;
|
|
gint i;
|
|
gint channels = 0;
|
|
gint rate;
|
|
guint64 channel_mask = 0;
|
|
gint caps_size;
|
|
GstStructure *structure;
|
|
GstAudioInfo info;
|
|
|
|
templcaps = gst_pad_get_pad_template_caps (dec->srcpad);
|
|
caps = gst_pad_peer_query_caps (dec->srcpad, templcaps);
|
|
if (caps)
|
|
gst_caps_unref (templcaps);
|
|
else
|
|
caps = templcaps;
|
|
templcaps = NULL;
|
|
|
|
if (!caps || gst_caps_is_empty (caps) || gst_caps_is_any (caps))
|
|
goto caps_error;
|
|
|
|
GST_LOG_OBJECT (dec, "peer caps %" GST_PTR_FORMAT, caps);
|
|
|
|
/* before fixating, try to use whatever upstream provided */
|
|
caps = gst_caps_make_writable (caps);
|
|
caps_size = gst_caps_get_size (caps);
|
|
if (dec->priv->ctx.input_caps) {
|
|
GstCaps *sinkcaps = dec->priv->ctx.input_caps;
|
|
GstStructure *structure = gst_caps_get_structure (sinkcaps, 0);
|
|
|
|
if (gst_structure_get_int (structure, "rate", &rate)) {
|
|
for (i = 0; i < caps_size; i++) {
|
|
gst_structure_set (gst_caps_get_structure (caps, i), "rate",
|
|
G_TYPE_INT, rate, NULL);
|
|
}
|
|
}
|
|
|
|
if (gst_structure_get_int (structure, "channels", &channels)) {
|
|
for (i = 0; i < caps_size; i++) {
|
|
gst_structure_set (gst_caps_get_structure (caps, i), "channels",
|
|
G_TYPE_INT, channels, NULL);
|
|
}
|
|
}
|
|
|
|
if (gst_structure_get (structure, "channel-mask", GST_TYPE_BITMASK,
|
|
&channel_mask, NULL)) {
|
|
for (i = 0; i < caps_size; i++) {
|
|
gst_structure_set (gst_caps_get_structure (caps, i), "channel-mask",
|
|
GST_TYPE_BITMASK, channel_mask, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < caps_size; i++) {
|
|
structure = gst_caps_get_structure (caps, i);
|
|
if (gst_structure_has_field (structure, "channels"))
|
|
gst_structure_fixate_field_nearest_int (structure,
|
|
"channels", GST_AUDIO_DEF_CHANNELS);
|
|
else
|
|
gst_structure_set (structure, "channels", G_TYPE_INT,
|
|
GST_AUDIO_DEF_CHANNELS, NULL);
|
|
if (gst_structure_has_field (structure, "rate"))
|
|
gst_structure_fixate_field_nearest_int (structure,
|
|
"rate", GST_AUDIO_DEF_RATE);
|
|
else
|
|
gst_structure_set (structure, "rate", G_TYPE_INT, GST_AUDIO_DEF_RATE,
|
|
NULL);
|
|
}
|
|
caps = gst_caps_fixate (caps);
|
|
structure = gst_caps_get_structure (caps, 0);
|
|
|
|
/* Need to add a channel-mask if channels > 2 */
|
|
gst_structure_get_int (structure, "channels", &channels);
|
|
if (channels > 2 && !gst_structure_has_field (structure, "channel-mask")) {
|
|
channel_mask = gst_audio_channel_get_fallback_mask (channels);
|
|
if (channel_mask != 0) {
|
|
gst_structure_set (structure, "channel-mask",
|
|
GST_TYPE_BITMASK, channel_mask, NULL);
|
|
} else {
|
|
GST_WARNING_OBJECT (dec, "No default channel-mask for %d channels",
|
|
channels);
|
|
}
|
|
}
|
|
|
|
if (!caps || !gst_audio_info_from_caps (&info, caps))
|
|
goto caps_error;
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->ctx.info = info;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
GST_INFO_OBJECT (dec,
|
|
"Chose default caps %" GST_PTR_FORMAT " for initial gap", caps);
|
|
gst_caps_unref (caps);
|
|
|
|
return TRUE;
|
|
|
|
caps_error:
|
|
{
|
|
if (caps)
|
|
gst_caps_unref (caps);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_handle_gap (GstAudioDecoder * dec, GstEvent * event)
|
|
{
|
|
gboolean ret;
|
|
GstClockTime timestamp, duration;
|
|
gboolean needs_reconfigure = FALSE;
|
|
|
|
/* Ensure we have caps first */
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
if (!GST_AUDIO_INFO_IS_VALID (&dec->priv->ctx.info)) {
|
|
if (!gst_audio_decoder_negotiate_default_caps (dec)) {
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
GST_ELEMENT_ERROR (dec, STREAM, FORMAT, (NULL),
|
|
("Decoder output not negotiated before GAP event."));
|
|
return FALSE;
|
|
}
|
|
needs_reconfigure = TRUE;
|
|
}
|
|
needs_reconfigure = gst_pad_check_reconfigure (dec->srcpad)
|
|
|| needs_reconfigure;
|
|
if (G_UNLIKELY (dec->priv->ctx.output_format_changed || needs_reconfigure)) {
|
|
if (!gst_audio_decoder_negotiate_unlocked (dec)) {
|
|
GST_WARNING_OBJECT (dec, "Failed to negotiate with downstream");
|
|
gst_pad_mark_reconfigure (dec->srcpad);
|
|
}
|
|
}
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
gst_event_parse_gap (event, ×tamp, &duration);
|
|
|
|
/* time progressed without data, see if we can fill the gap with
|
|
* some concealment data */
|
|
GST_DEBUG_OBJECT (dec,
|
|
"gap event: plc %d, do_plc %d, position %" GST_TIME_FORMAT
|
|
" duration %" GST_TIME_FORMAT,
|
|
dec->priv->plc, dec->priv->ctx.do_plc,
|
|
GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration));
|
|
|
|
if (dec->priv->plc && dec->priv->ctx.do_plc && dec->input_segment.rate > 0.0) {
|
|
GstAudioDecoderClass *klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
GstBuffer *buf;
|
|
|
|
/* hand subclass empty frame with duration that needs covering */
|
|
buf = gst_buffer_new ();
|
|
GST_BUFFER_TIMESTAMP (buf) = timestamp;
|
|
GST_BUFFER_DURATION (buf) = duration;
|
|
/* best effort, not much error handling */
|
|
gst_audio_decoder_handle_frame (dec, klass, buf);
|
|
ret = TRUE;
|
|
dec->priv->expecting_discont_buf = TRUE;
|
|
gst_event_unref (event);
|
|
} else {
|
|
GstFlowReturn flowret;
|
|
|
|
/* sub-class doesn't know how to handle empty buffers,
|
|
* so just try sending GAP downstream */
|
|
flowret = check_pending_reconfigure (dec);
|
|
if (flowret == GST_FLOW_OK) {
|
|
send_pending_events (dec);
|
|
ret = gst_audio_decoder_push_event (dec, event);
|
|
} else {
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static GList *
|
|
_flush_events (GstPad * pad, GList * events)
|
|
{
|
|
GList *tmp;
|
|
|
|
for (tmp = events; tmp; tmp = tmp->next) {
|
|
if (GST_EVENT_TYPE (tmp->data) != GST_EVENT_EOS &&
|
|
GST_EVENT_TYPE (tmp->data) != GST_EVENT_SEGMENT &&
|
|
GST_EVENT_IS_STICKY (tmp->data)) {
|
|
gst_pad_store_sticky_event (pad, GST_EVENT_CAST (tmp->data));
|
|
}
|
|
gst_event_unref (tmp->data);
|
|
}
|
|
g_list_free (events);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_sink_eventfunc (GstAudioDecoder * dec, GstEvent * event)
|
|
{
|
|
gboolean ret;
|
|
|
|
switch (GST_EVENT_TYPE (event)) {
|
|
case GST_EVENT_STREAM_START:
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
/* finish any data in current segment and clear the decoder
|
|
* to be ready for new stream data */
|
|
gst_audio_decoder_drain (dec);
|
|
gst_audio_decoder_flush (dec, FALSE);
|
|
|
|
GST_DEBUG_OBJECT (dec, "received STREAM_START. Clearing taglist");
|
|
/* Flush upstream tags after a STREAM_START */
|
|
if (dec->priv->upstream_tags) {
|
|
gst_tag_list_unref (dec->priv->upstream_tags);
|
|
dec->priv->upstream_tags = NULL;
|
|
dec->priv->taglist_changed = TRUE;
|
|
}
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
ret = gst_audio_decoder_push_event (dec, event);
|
|
break;
|
|
case GST_EVENT_SEGMENT:
|
|
{
|
|
GstSegment seg;
|
|
GstFormat format;
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
gst_event_copy_segment (event, &seg);
|
|
|
|
format = seg.format;
|
|
if (format == GST_FORMAT_TIME) {
|
|
GST_DEBUG_OBJECT (dec, "received TIME SEGMENT %" GST_SEGMENT_FORMAT,
|
|
&seg);
|
|
} else {
|
|
gint64 nstart;
|
|
GST_DEBUG_OBJECT (dec, "received SEGMENT %" GST_SEGMENT_FORMAT, &seg);
|
|
/* handle newsegment resulting from legacy simple seeking */
|
|
/* note that we need to convert this whether or not enough data
|
|
* to handle initial newsegment */
|
|
if (dec->priv->ctx.do_estimate_rate &&
|
|
gst_pad_query_convert (dec->sinkpad, GST_FORMAT_BYTES, seg.start,
|
|
GST_FORMAT_TIME, &nstart)) {
|
|
/* best attempt convert */
|
|
/* as these are only estimates, stop is kept open-ended to avoid
|
|
* premature cutting */
|
|
GST_DEBUG_OBJECT (dec, "converted to TIME start %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (nstart));
|
|
seg.format = GST_FORMAT_TIME;
|
|
seg.start = nstart;
|
|
seg.time = nstart;
|
|
seg.stop = GST_CLOCK_TIME_NONE;
|
|
/* replace event */
|
|
gst_event_unref (event);
|
|
event = gst_event_new_segment (&seg);
|
|
} else {
|
|
GST_DEBUG_OBJECT (dec, "unsupported format; ignoring");
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
gst_event_unref (event);
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* prepare for next segment */
|
|
/* Use the segment start as a base timestamp
|
|
* in case upstream does not come up with anything better
|
|
* (e.g. upstream BYTE) */
|
|
if (format != GST_FORMAT_TIME) {
|
|
dec->priv->base_ts = seg.start;
|
|
dec->priv->samples = 0;
|
|
}
|
|
|
|
/* and follow along with segment */
|
|
dec->priv->in_out_segment_sync = FALSE;
|
|
dec->input_segment = seg;
|
|
dec->priv->pending_events =
|
|
g_list_append (dec->priv->pending_events, event);
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
case GST_EVENT_GAP:
|
|
ret = gst_audio_decoder_handle_gap (dec, event);
|
|
break;
|
|
case GST_EVENT_FLUSH_STOP:
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
/* prepare for fresh start */
|
|
gst_audio_decoder_flush (dec, TRUE);
|
|
|
|
dec->priv->pending_events = _flush_events (dec->srcpad,
|
|
dec->priv->pending_events);
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
/* Forward FLUSH_STOP, it is expected to be forwarded immediately
|
|
* and no buffers are queued anyway. */
|
|
ret = gst_audio_decoder_push_event (dec, event);
|
|
break;
|
|
|
|
case GST_EVENT_SEGMENT_DONE:
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
gst_audio_decoder_drain (dec);
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
/* Forward SEGMENT_DONE because no buffer or serialized event might come after
|
|
* SEGMENT_DONE and nothing could trigger another _finish_frame() call. */
|
|
if (dec->priv->pending_events)
|
|
send_pending_events (dec);
|
|
ret = gst_audio_decoder_push_event (dec, event);
|
|
break;
|
|
|
|
case GST_EVENT_EOS:
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
gst_audio_decoder_drain (dec);
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
if (dec->priv->ctx.had_input_data && !dec->priv->ctx.had_output_data) {
|
|
GST_ELEMENT_ERROR (dec, STREAM, DECODE,
|
|
("No valid frames decoded before end of stream"),
|
|
("no valid frames found"));
|
|
}
|
|
|
|
/* Forward EOS because no buffer or serialized event will come after
|
|
* EOS and nothing could trigger another _finish_frame() call. */
|
|
if (dec->priv->pending_events)
|
|
send_pending_events (dec);
|
|
ret = gst_audio_decoder_push_event (dec, event);
|
|
break;
|
|
|
|
case GST_EVENT_CAPS:
|
|
{
|
|
GstCaps *caps;
|
|
|
|
gst_event_parse_caps (event, &caps);
|
|
ret = gst_audio_decoder_sink_setcaps (dec, caps);
|
|
gst_event_unref (event);
|
|
break;
|
|
}
|
|
case GST_EVENT_TAG:
|
|
{
|
|
GstTagList *tags;
|
|
|
|
gst_event_parse_tag (event, &tags);
|
|
|
|
if (gst_tag_list_get_scope (tags) == GST_TAG_SCOPE_STREAM) {
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
if (dec->priv->upstream_tags != tags) {
|
|
if (dec->priv->upstream_tags)
|
|
gst_tag_list_unref (dec->priv->upstream_tags);
|
|
dec->priv->upstream_tags = gst_tag_list_ref (tags);
|
|
GST_INFO_OBJECT (dec, "upstream stream tags: %" GST_PTR_FORMAT, tags);
|
|
}
|
|
gst_event_unref (event);
|
|
event = gst_audio_decoder_create_merged_tags_event (dec);
|
|
dec->priv->taglist_changed = FALSE;
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
/* No tags, go out of here instead of fall through */
|
|
if (!event) {
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* fall through */
|
|
}
|
|
default:
|
|
if (!GST_EVENT_IS_SERIALIZED (event)) {
|
|
ret =
|
|
gst_pad_event_default (dec->sinkpad, GST_OBJECT_CAST (dec), event);
|
|
} else {
|
|
GST_DEBUG_OBJECT (dec, "Enqueuing event %d, %s", GST_EVENT_TYPE (event),
|
|
GST_EVENT_TYPE_NAME (event));
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
dec->priv->pending_events =
|
|
g_list_append (dec->priv->pending_events, event);
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
ret = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_sink_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event)
|
|
{
|
|
GstAudioDecoder *dec;
|
|
GstAudioDecoderClass *klass;
|
|
gboolean ret;
|
|
|
|
dec = GST_AUDIO_DECODER (parent);
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
GST_DEBUG_OBJECT (dec, "received event %d, %s", GST_EVENT_TYPE (event),
|
|
GST_EVENT_TYPE_NAME (event));
|
|
|
|
if (klass->sink_event)
|
|
ret = klass->sink_event (dec, event);
|
|
else {
|
|
gst_event_unref (event);
|
|
ret = FALSE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_do_seek (GstAudioDecoder * dec, GstEvent * event)
|
|
{
|
|
GstSeekFlags flags;
|
|
GstSeekType start_type, end_type;
|
|
GstFormat format;
|
|
gdouble rate;
|
|
gint64 start, start_time, end_time;
|
|
GstSegment seek_segment;
|
|
guint32 seqnum;
|
|
|
|
gst_event_parse_seek (event, &rate, &format, &flags, &start_type,
|
|
&start_time, &end_type, &end_time);
|
|
|
|
/* we'll handle plain open-ended flushing seeks with the simple approach */
|
|
if (rate != 1.0) {
|
|
GST_DEBUG_OBJECT (dec, "unsupported seek: rate");
|
|
return FALSE;
|
|
}
|
|
|
|
if (start_type != GST_SEEK_TYPE_SET) {
|
|
GST_DEBUG_OBJECT (dec, "unsupported seek: start time");
|
|
return FALSE;
|
|
}
|
|
|
|
if ((end_type != GST_SEEK_TYPE_SET && end_type != GST_SEEK_TYPE_NONE) ||
|
|
(end_type == GST_SEEK_TYPE_SET && end_time != GST_CLOCK_TIME_NONE)) {
|
|
GST_DEBUG_OBJECT (dec, "unsupported seek: end time");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!(flags & GST_SEEK_FLAG_FLUSH)) {
|
|
GST_DEBUG_OBJECT (dec, "unsupported seek: not flushing");
|
|
return FALSE;
|
|
}
|
|
|
|
memcpy (&seek_segment, &dec->output_segment, sizeof (seek_segment));
|
|
gst_segment_do_seek (&seek_segment, rate, format, flags, start_type,
|
|
start_time, end_type, end_time, NULL);
|
|
start_time = seek_segment.position;
|
|
|
|
if (!gst_pad_query_convert (dec->sinkpad, GST_FORMAT_TIME, start_time,
|
|
GST_FORMAT_BYTES, &start)) {
|
|
GST_DEBUG_OBJECT (dec, "conversion failed");
|
|
return FALSE;
|
|
}
|
|
|
|
seqnum = gst_event_get_seqnum (event);
|
|
event = gst_event_new_seek (1.0, GST_FORMAT_BYTES, flags,
|
|
GST_SEEK_TYPE_SET, start, GST_SEEK_TYPE_NONE, -1);
|
|
gst_event_set_seqnum (event, seqnum);
|
|
|
|
GST_DEBUG_OBJECT (dec, "seeking to %" GST_TIME_FORMAT " at byte offset %"
|
|
G_GINT64_FORMAT, GST_TIME_ARGS (start_time), start);
|
|
|
|
return gst_pad_push_event (dec->sinkpad, event);
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_src_eventfunc (GstAudioDecoder * dec, GstEvent * event)
|
|
{
|
|
gboolean res;
|
|
|
|
switch (GST_EVENT_TYPE (event)) {
|
|
case GST_EVENT_SEEK:
|
|
{
|
|
GstFormat format;
|
|
gdouble rate;
|
|
GstSeekFlags flags;
|
|
GstSeekType start_type, stop_type;
|
|
gint64 start, stop;
|
|
gint64 tstart, tstop;
|
|
guint32 seqnum;
|
|
|
|
gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
|
|
&stop_type, &stop);
|
|
seqnum = gst_event_get_seqnum (event);
|
|
|
|
/* upstream gets a chance first */
|
|
if ((res = gst_pad_push_event (dec->sinkpad, event)))
|
|
break;
|
|
|
|
/* if upstream fails for a time seek, maybe we can help if allowed */
|
|
if (format == GST_FORMAT_TIME) {
|
|
if (gst_audio_decoder_do_byte (dec))
|
|
res = gst_audio_decoder_do_seek (dec, event);
|
|
break;
|
|
}
|
|
|
|
/* ... though a non-time seek can be aided as well */
|
|
/* First bring the requested format to time */
|
|
if (!(res =
|
|
gst_pad_query_convert (dec->srcpad, format, start,
|
|
GST_FORMAT_TIME, &tstart)))
|
|
goto convert_error;
|
|
if (!(res =
|
|
gst_pad_query_convert (dec->srcpad, format, stop, GST_FORMAT_TIME,
|
|
&tstop)))
|
|
goto convert_error;
|
|
|
|
/* then seek with time on the peer */
|
|
event = gst_event_new_seek (rate, GST_FORMAT_TIME,
|
|
flags, start_type, tstart, stop_type, tstop);
|
|
gst_event_set_seqnum (event, seqnum);
|
|
|
|
res = gst_pad_push_event (dec->sinkpad, event);
|
|
break;
|
|
}
|
|
default:
|
|
res = gst_pad_event_default (dec->srcpad, GST_OBJECT_CAST (dec), event);
|
|
break;
|
|
}
|
|
done:
|
|
return res;
|
|
|
|
/* ERRORS */
|
|
convert_error:
|
|
{
|
|
GST_DEBUG_OBJECT (dec, "cannot convert start/stop for seek");
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
|
|
{
|
|
GstAudioDecoder *dec;
|
|
GstAudioDecoderClass *klass;
|
|
gboolean ret;
|
|
|
|
dec = GST_AUDIO_DECODER (parent);
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
GST_DEBUG_OBJECT (dec, "received event %d, %s", GST_EVENT_TYPE (event),
|
|
GST_EVENT_TYPE_NAME (event));
|
|
|
|
if (klass->src_event)
|
|
ret = klass->src_event (dec, event);
|
|
else {
|
|
gst_event_unref (event);
|
|
ret = FALSE;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_decide_allocation_default (GstAudioDecoder * 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_audio_decoder_propose_allocation_default (GstAudioDecoder * dec,
|
|
GstQuery * query)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_proxy_getcaps:
|
|
* @decoder: a #GstAudioDecoder
|
|
* @caps: (allow-none): initial caps
|
|
* @filter: (allow-none): filter caps
|
|
*
|
|
* Returns caps that express @caps (or sink template caps if @caps == NULL)
|
|
* restricted to rate/channels/... combinations supported by downstream
|
|
* elements.
|
|
*
|
|
* Returns: (transfer full): a #GstCaps owned by caller
|
|
*
|
|
* Since: 1.6
|
|
*/
|
|
GstCaps *
|
|
gst_audio_decoder_proxy_getcaps (GstAudioDecoder * decoder, GstCaps * caps,
|
|
GstCaps * filter)
|
|
{
|
|
return __gst_audio_element_proxy_getcaps (GST_ELEMENT_CAST (decoder),
|
|
GST_AUDIO_DECODER_SINK_PAD (decoder),
|
|
GST_AUDIO_DECODER_SRC_PAD (decoder), caps, filter);
|
|
}
|
|
|
|
static GstCaps *
|
|
gst_audio_decoder_sink_getcaps (GstAudioDecoder * decoder, GstCaps * filter)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
GstCaps *caps;
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (decoder);
|
|
|
|
if (klass->getcaps)
|
|
caps = klass->getcaps (decoder, filter);
|
|
else
|
|
caps = gst_audio_decoder_proxy_getcaps (decoder, NULL, filter);
|
|
|
|
GST_LOG_OBJECT (decoder, "Returning caps %" GST_PTR_FORMAT, caps);
|
|
|
|
return caps;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_sink_query_default (GstAudioDecoder * dec, GstQuery * query)
|
|
{
|
|
GstPad *pad = GST_AUDIO_DECODER_SINK_PAD (dec);
|
|
gboolean res = FALSE;
|
|
|
|
GST_LOG_OBJECT (dec, "handling query: %" GST_PTR_FORMAT, query);
|
|
|
|
switch (GST_QUERY_TYPE (query)) {
|
|
case GST_QUERY_FORMATS:
|
|
{
|
|
gst_query_set_formats (query, 2, GST_FORMAT_TIME, GST_FORMAT_BYTES);
|
|
res = TRUE;
|
|
break;
|
|
}
|
|
case GST_QUERY_CONVERT:
|
|
{
|
|
GstFormat src_fmt, dest_fmt;
|
|
gint64 src_val, dest_val;
|
|
|
|
gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
|
|
GST_OBJECT_LOCK (dec);
|
|
res = __gst_audio_encoded_audio_convert (&dec->priv->ctx.info,
|
|
dec->priv->bytes_in, dec->priv->samples_out,
|
|
src_fmt, src_val, &dest_fmt, &dest_val);
|
|
GST_OBJECT_UNLOCK (dec);
|
|
if (!res)
|
|
goto error;
|
|
gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
|
|
break;
|
|
}
|
|
case GST_QUERY_ALLOCATION:
|
|
{
|
|
GstAudioDecoderClass *klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
if (klass->propose_allocation)
|
|
res = klass->propose_allocation (dec, query);
|
|
break;
|
|
}
|
|
case GST_QUERY_CAPS:{
|
|
GstCaps *filter, *caps;
|
|
|
|
gst_query_parse_caps (query, &filter);
|
|
caps = gst_audio_decoder_sink_getcaps (dec, filter);
|
|
gst_query_set_caps_result (query, caps);
|
|
gst_caps_unref (caps);
|
|
res = TRUE;
|
|
break;
|
|
}
|
|
case GST_QUERY_ACCEPT_CAPS:{
|
|
if (dec->priv->use_default_pad_acceptcaps) {
|
|
res =
|
|
gst_pad_query_default (GST_AUDIO_DECODER_SINK_PAD (dec),
|
|
GST_OBJECT_CAST (dec), query);
|
|
} else {
|
|
GstCaps *caps;
|
|
GstCaps *allowed_caps;
|
|
GstCaps *template_caps;
|
|
gboolean accept;
|
|
|
|
gst_query_parse_accept_caps (query, &caps);
|
|
|
|
template_caps = gst_pad_get_pad_template_caps (pad);
|
|
accept = gst_caps_is_subset (caps, template_caps);
|
|
gst_caps_unref (template_caps);
|
|
|
|
if (accept) {
|
|
allowed_caps = gst_pad_query_caps (GST_AUDIO_DECODER_SINK_PAD (dec),
|
|
caps);
|
|
|
|
accept = gst_caps_can_intersect (caps, allowed_caps);
|
|
|
|
gst_caps_unref (allowed_caps);
|
|
}
|
|
|
|
gst_query_set_accept_caps_result (query, accept);
|
|
res = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
case GST_QUERY_SEEKING:
|
|
{
|
|
GstFormat format;
|
|
|
|
/* non-TIME segments are discarded, so we won't seek that way either */
|
|
gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
|
|
if (format != GST_FORMAT_TIME) {
|
|
GST_DEBUG_OBJECT (dec, "discarding non-TIME SEEKING query");
|
|
res = FALSE;
|
|
break;
|
|
}
|
|
/* fall-through */
|
|
}
|
|
default:
|
|
res = gst_pad_query_default (pad, GST_OBJECT_CAST (dec), query);
|
|
break;
|
|
}
|
|
|
|
error:
|
|
return res;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_sink_query (GstPad * pad, GstObject * parent,
|
|
GstQuery * query)
|
|
{
|
|
GstAudioDecoderClass *dec_class;
|
|
GstAudioDecoder *dec;
|
|
gboolean ret = FALSE;
|
|
|
|
dec = GST_AUDIO_DECODER (parent);
|
|
dec_class = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
GST_DEBUG_OBJECT (pad, "received query %" GST_PTR_FORMAT, query);
|
|
|
|
if (dec_class->sink_query)
|
|
ret = dec_class->sink_query (dec, query);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* FIXME ? are any of these queries (other than latency) a decoder's business ??
|
|
* also, the conversion stuff might seem to make sense, but seems to not mind
|
|
* segment stuff etc at all
|
|
* Supposedly that's backward compatibility ... */
|
|
static gboolean
|
|
gst_audio_decoder_src_query_default (GstAudioDecoder * dec, GstQuery * query)
|
|
{
|
|
GstPad *pad = GST_AUDIO_DECODER_SRC_PAD (dec);
|
|
gboolean res = FALSE;
|
|
|
|
GST_LOG_OBJECT (dec, "handling query: %" GST_PTR_FORMAT, query);
|
|
|
|
switch (GST_QUERY_TYPE (query)) {
|
|
case GST_QUERY_DURATION:
|
|
{
|
|
GstFormat format;
|
|
|
|
/* upstream in any case */
|
|
if ((res = gst_pad_query_default (pad, GST_OBJECT_CAST (dec), query)))
|
|
break;
|
|
|
|
gst_query_parse_duration (query, &format, NULL);
|
|
/* try answering TIME by converting from BYTE if subclass allows */
|
|
if (format == GST_FORMAT_TIME && gst_audio_decoder_do_byte (dec)) {
|
|
gint64 value;
|
|
|
|
if (gst_pad_peer_query_duration (dec->sinkpad, GST_FORMAT_BYTES,
|
|
&value)) {
|
|
GST_LOG_OBJECT (dec, "upstream size %" G_GINT64_FORMAT, value);
|
|
if (gst_pad_query_convert (dec->sinkpad, GST_FORMAT_BYTES, value,
|
|
GST_FORMAT_TIME, &value)) {
|
|
gst_query_set_duration (query, GST_FORMAT_TIME, value);
|
|
res = TRUE;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GST_QUERY_POSITION:
|
|
{
|
|
GstFormat format;
|
|
gint64 time, value;
|
|
|
|
if ((res = gst_pad_peer_query (dec->sinkpad, query))) {
|
|
GST_LOG_OBJECT (dec, "returning peer response");
|
|
break;
|
|
}
|
|
|
|
/* Refuse BYTES format queries. If it made sense to
|
|
* answer them, upstream would have already */
|
|
gst_query_parse_position (query, &format, NULL);
|
|
|
|
if (format == GST_FORMAT_BYTES) {
|
|
GST_LOG_OBJECT (dec, "Ignoring BYTES position query");
|
|
break;
|
|
}
|
|
|
|
/* we start from the last seen time */
|
|
time = dec->output_segment.position;
|
|
/* correct for the segment values */
|
|
time =
|
|
gst_segment_to_stream_time (&dec->output_segment, GST_FORMAT_TIME,
|
|
time);
|
|
|
|
GST_LOG_OBJECT (dec,
|
|
"query %p: our time: %" GST_TIME_FORMAT, query, GST_TIME_ARGS (time));
|
|
|
|
/* and convert to the final format */
|
|
if (!(res = gst_pad_query_convert (pad, GST_FORMAT_TIME, time,
|
|
format, &value)))
|
|
break;
|
|
|
|
gst_query_set_position (query, format, value);
|
|
|
|
GST_LOG_OBJECT (dec,
|
|
"query %p: we return %" G_GINT64_FORMAT " (format %u)", query, value,
|
|
format);
|
|
break;
|
|
}
|
|
case GST_QUERY_FORMATS:
|
|
{
|
|
gst_query_set_formats (query, 3,
|
|
GST_FORMAT_TIME, GST_FORMAT_BYTES, GST_FORMAT_DEFAULT);
|
|
res = TRUE;
|
|
break;
|
|
}
|
|
case GST_QUERY_CONVERT:
|
|
{
|
|
GstFormat src_fmt, dest_fmt;
|
|
gint64 src_val, dest_val;
|
|
|
|
gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
|
|
GST_OBJECT_LOCK (dec);
|
|
res = gst_audio_info_convert (&dec->priv->ctx.info,
|
|
src_fmt, src_val, dest_fmt, &dest_val);
|
|
GST_OBJECT_UNLOCK (dec);
|
|
if (!res)
|
|
break;
|
|
gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
|
|
break;
|
|
}
|
|
case GST_QUERY_LATENCY:
|
|
{
|
|
if ((res = gst_pad_peer_query (dec->sinkpad, query))) {
|
|
gboolean live;
|
|
GstClockTime min_latency, max_latency;
|
|
|
|
gst_query_parse_latency (query, &live, &min_latency, &max_latency);
|
|
GST_DEBUG_OBJECT (dec, "Peer latency: live %d, min %"
|
|
GST_TIME_FORMAT " max %" GST_TIME_FORMAT, live,
|
|
GST_TIME_ARGS (min_latency), GST_TIME_ARGS (max_latency));
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
/* add our latency */
|
|
min_latency += dec->priv->ctx.min_latency;
|
|
if (max_latency == -1 || dec->priv->ctx.max_latency == -1)
|
|
max_latency = -1;
|
|
else
|
|
max_latency += dec->priv->ctx.max_latency;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
gst_query_set_latency (query, live, min_latency, max_latency);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
res = gst_pad_query_default (pad, GST_OBJECT_CAST (dec), query);
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
|
|
{
|
|
GstAudioDecoder *dec;
|
|
GstAudioDecoderClass *dec_class;
|
|
gboolean ret = FALSE;
|
|
|
|
dec = GST_AUDIO_DECODER (parent);
|
|
dec_class = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
GST_DEBUG_OBJECT (pad, "received query %" GST_PTR_FORMAT, query);
|
|
|
|
if (dec_class->src_query)
|
|
ret = dec_class->src_query (dec, query);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_stop (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
gboolean ret = TRUE;
|
|
|
|
GST_DEBUG_OBJECT (dec, "gst_audio_decoder_stop");
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
if (klass->stop) {
|
|
ret = klass->stop (dec);
|
|
}
|
|
|
|
/* clean up */
|
|
gst_audio_decoder_reset (dec, TRUE);
|
|
|
|
if (ret)
|
|
dec->priv->active = FALSE;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_audio_decoder_start (GstAudioDecoder * dec)
|
|
{
|
|
GstAudioDecoderClass *klass;
|
|
gboolean ret = TRUE;
|
|
|
|
GST_DEBUG_OBJECT (dec, "gst_audio_decoder_start");
|
|
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (dec);
|
|
|
|
/* arrange clean state */
|
|
gst_audio_decoder_reset (dec, TRUE);
|
|
|
|
if (klass->start) {
|
|
ret = klass->start (dec);
|
|
}
|
|
|
|
if (ret)
|
|
dec->priv->active = TRUE;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
gst_audio_decoder_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstAudioDecoder *dec;
|
|
|
|
dec = GST_AUDIO_DECODER (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_LATENCY:
|
|
g_value_set_int64 (value, dec->priv->latency);
|
|
break;
|
|
case PROP_TOLERANCE:
|
|
g_value_set_int64 (value, dec->priv->tolerance);
|
|
break;
|
|
case PROP_PLC:
|
|
g_value_set_boolean (value, dec->priv->plc);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_audio_decoder_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstAudioDecoder *dec;
|
|
|
|
dec = GST_AUDIO_DECODER (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_LATENCY:
|
|
dec->priv->latency = g_value_get_int64 (value);
|
|
break;
|
|
case PROP_TOLERANCE:
|
|
dec->priv->tolerance = g_value_get_int64 (value);
|
|
break;
|
|
case PROP_PLC:
|
|
dec->priv->plc = g_value_get_boolean (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static GstStateChangeReturn
|
|
gst_audio_decoder_change_state (GstElement * element, GstStateChange transition)
|
|
{
|
|
GstAudioDecoder *codec;
|
|
GstAudioDecoderClass *klass;
|
|
GstStateChangeReturn ret;
|
|
|
|
codec = GST_AUDIO_DECODER (element);
|
|
klass = GST_AUDIO_DECODER_GET_CLASS (codec);
|
|
|
|
switch (transition) {
|
|
case GST_STATE_CHANGE_NULL_TO_READY:
|
|
if (klass->open) {
|
|
if (!klass->open (codec))
|
|
goto open_failed;
|
|
}
|
|
break;
|
|
case GST_STATE_CHANGE_READY_TO_PAUSED:
|
|
if (!gst_audio_decoder_start (codec)) {
|
|
goto start_failed;
|
|
}
|
|
break;
|
|
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
|
|
|
|
switch (transition) {
|
|
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
|
|
break;
|
|
case GST_STATE_CHANGE_PAUSED_TO_READY:
|
|
if (!gst_audio_decoder_stop (codec)) {
|
|
goto stop_failed;
|
|
}
|
|
break;
|
|
case GST_STATE_CHANGE_READY_TO_NULL:
|
|
if (klass->close) {
|
|
if (!klass->close (codec))
|
|
goto close_failed;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
|
|
start_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (codec, LIBRARY, INIT, (NULL), ("Failed to start codec"));
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
}
|
|
stop_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (codec, LIBRARY, INIT, (NULL), ("Failed to stop codec"));
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
}
|
|
open_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (codec, LIBRARY, INIT, (NULL), ("Failed to open codec"));
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
}
|
|
close_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (codec, LIBRARY, INIT, (NULL), ("Failed to close codec"));
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
}
|
|
}
|
|
|
|
GstFlowReturn
|
|
_gst_audio_decoder_error (GstAudioDecoder * dec, gint weight,
|
|
GQuark domain, gint code, gchar * txt, gchar * dbg, const gchar * file,
|
|
const gchar * function, gint line)
|
|
{
|
|
if (txt)
|
|
GST_WARNING_OBJECT (dec, "error: %s", txt);
|
|
if (dbg)
|
|
GST_WARNING_OBJECT (dec, "error: %s", dbg);
|
|
dec->priv->error_count += weight;
|
|
dec->priv->discont = TRUE;
|
|
if (dec->priv->ctx.max_errors >= 0
|
|
&& dec->priv->ctx.max_errors < dec->priv->error_count) {
|
|
gst_element_message_full (GST_ELEMENT (dec), GST_MESSAGE_ERROR, domain,
|
|
code, txt, dbg, file, function, line);
|
|
return GST_FLOW_ERROR;
|
|
} else {
|
|
g_free (txt);
|
|
g_free (dbg);
|
|
return GST_FLOW_OK;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_audio_info:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Returns: a #GstAudioInfo describing the input audio format
|
|
*/
|
|
GstAudioInfo *
|
|
gst_audio_decoder_get_audio_info (GstAudioDecoder * dec)
|
|
{
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), NULL);
|
|
|
|
return &dec->priv->ctx.info;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_plc_aware:
|
|
* @dec: a #GstAudioDecoder
|
|
* @plc: new plc state
|
|
*
|
|
* Indicates whether or not subclass handles packet loss concealment (plc).
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_plc_aware (GstAudioDecoder * dec, gboolean plc)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
dec->priv->ctx.do_plc = plc;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_plc_aware:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Returns: currently configured plc handling
|
|
*/
|
|
gint
|
|
gst_audio_decoder_get_plc_aware (GstAudioDecoder * dec)
|
|
{
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), 0);
|
|
|
|
return dec->priv->ctx.do_plc;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_estimate_rate:
|
|
* @dec: a #GstAudioDecoder
|
|
* @enabled: whether to enable byte to time conversion
|
|
*
|
|
* Allows baseclass to perform byte to time estimated conversion.
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_estimate_rate (GstAudioDecoder * dec, gboolean enabled)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
dec->priv->ctx.do_estimate_rate = enabled;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_estimate_rate:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Returns: currently configured byte to time conversion setting
|
|
*/
|
|
gint
|
|
gst_audio_decoder_get_estimate_rate (GstAudioDecoder * dec)
|
|
{
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), 0);
|
|
|
|
return dec->priv->ctx.do_estimate_rate;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_delay:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Returns: currently configured decoder delay
|
|
*/
|
|
gint
|
|
gst_audio_decoder_get_delay (GstAudioDecoder * dec)
|
|
{
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), 0);
|
|
|
|
return dec->priv->ctx.delay;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_max_errors:
|
|
* @dec: a #GstAudioDecoder
|
|
* @num: max tolerated errors
|
|
*
|
|
* Sets numbers of tolerated decoder errors, where a tolerated one is then only
|
|
* warned about, but more than tolerated will lead to fatal error. You can set
|
|
* -1 for never returning fatal errors. Default is set to
|
|
* GST_AUDIO_DECODER_MAX_ERRORS.
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_max_errors (GstAudioDecoder * dec, gint num)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
dec->priv->ctx.max_errors = num;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_max_errors:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Returns: currently configured decoder tolerated error count.
|
|
*/
|
|
gint
|
|
gst_audio_decoder_get_max_errors (GstAudioDecoder * dec)
|
|
{
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), 0);
|
|
|
|
return dec->priv->ctx.max_errors;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_latency:
|
|
* @dec: a #GstAudioDecoder
|
|
* @min: minimum latency
|
|
* @max: maximum latency
|
|
*
|
|
* Sets decoder latency.
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_latency (GstAudioDecoder * dec,
|
|
GstClockTime min, GstClockTime max)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
g_return_if_fail (GST_CLOCK_TIME_IS_VALID (min));
|
|
g_return_if_fail (min <= max);
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->ctx.min_latency = min;
|
|
dec->priv->ctx.max_latency = max;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
/* post latency message on the bus */
|
|
gst_element_post_message (GST_ELEMENT (dec),
|
|
gst_message_new_latency (GST_OBJECT (dec)));
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_latency:
|
|
* @dec: a #GstAudioDecoder
|
|
* @min: (out) (allow-none): a pointer to storage to hold minimum latency
|
|
* @max: (out) (allow-none): a pointer to storage to hold maximum latency
|
|
*
|
|
* Sets the variables pointed to by @min and @max to the currently configured
|
|
* latency.
|
|
*/
|
|
void
|
|
gst_audio_decoder_get_latency (GstAudioDecoder * dec,
|
|
GstClockTime * min, GstClockTime * max)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
if (min)
|
|
*min = dec->priv->ctx.min_latency;
|
|
if (max)
|
|
*max = dec->priv->ctx.max_latency;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_parse_state:
|
|
* @dec: a #GstAudioDecoder
|
|
* @sync: a pointer to a variable to hold the current sync state
|
|
* @eos: a pointer to a variable to hold the current eos state
|
|
*
|
|
* Return current parsing (sync and eos) state.
|
|
*/
|
|
void
|
|
gst_audio_decoder_get_parse_state (GstAudioDecoder * dec,
|
|
gboolean * sync, gboolean * eos)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
if (sync)
|
|
*sync = dec->priv->ctx.sync;
|
|
if (eos)
|
|
*eos = dec->priv->ctx.eos;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_allocation_caps:
|
|
* @dec: a #GstAudioDecoder
|
|
* @allocation_caps: (allow-none): a #GstCaps or %NULL
|
|
*
|
|
* Sets a caps in allocation query which are different from the set
|
|
* pad's caps. Use this function before calling
|
|
* gst_audio_decoder_negotiate(). Setting to %NULL the allocation
|
|
* query will use the caps from the pad.
|
|
*
|
|
* Since: 1.10
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_allocation_caps (GstAudioDecoder * dec,
|
|
GstCaps * allocation_caps)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
gst_caps_replace (&dec->priv->ctx.allocation_caps, allocation_caps);
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_plc:
|
|
* @dec: a #GstAudioDecoder
|
|
* @enabled: new state
|
|
*
|
|
* Enable or disable decoder packet loss concealment, provided subclass
|
|
* and codec are capable and allow handling plc.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_plc (GstAudioDecoder * dec, gboolean enabled)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
GST_LOG_OBJECT (dec, "enabled: %d", enabled);
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->plc = enabled;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_plc:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Queries decoder packet loss concealment handling.
|
|
*
|
|
* Returns: TRUE if packet loss concealment is enabled.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
gboolean
|
|
gst_audio_decoder_get_plc (GstAudioDecoder * dec)
|
|
{
|
|
gboolean result;
|
|
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), FALSE);
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
result = dec->priv->plc;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_min_latency:
|
|
* @dec: a #GstAudioDecoder
|
|
* @num: new minimum latency
|
|
*
|
|
* Sets decoder minimum aggregation latency.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_min_latency (GstAudioDecoder * dec, GstClockTime num)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->latency = num;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_min_latency:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Queries decoder's latency aggregation.
|
|
*
|
|
* Returns: aggregation latency.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
GstClockTime
|
|
gst_audio_decoder_get_min_latency (GstAudioDecoder * dec)
|
|
{
|
|
GstClockTime result;
|
|
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), FALSE);
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
result = dec->priv->latency;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_tolerance:
|
|
* @dec: a #GstAudioDecoder
|
|
* @tolerance: new tolerance
|
|
*
|
|
* Configures decoder audio jitter tolerance threshold.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_tolerance (GstAudioDecoder * dec, GstClockTime tolerance)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->tolerance = tolerance;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_tolerance:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Queries current audio jitter tolerance threshold.
|
|
*
|
|
* Returns: decoder audio jitter tolerance threshold.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
GstClockTime
|
|
gst_audio_decoder_get_tolerance (GstAudioDecoder * dec)
|
|
{
|
|
GstClockTime result;
|
|
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), 0);
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
result = dec->priv->tolerance;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_drainable:
|
|
* @dec: a #GstAudioDecoder
|
|
* @enabled: new state
|
|
*
|
|
* Configures decoder drain handling. If drainable, subclass might
|
|
* be handed a NULL buffer to have it return any leftover decoded data.
|
|
* Otherwise, it is not considered so capable and will only ever be passed
|
|
* real data.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_drainable (GstAudioDecoder * dec, gboolean enabled)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->drainable = enabled;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_drainable:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Queries decoder drain handling.
|
|
*
|
|
* Returns: TRUE if drainable handling is enabled.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
gboolean
|
|
gst_audio_decoder_get_drainable (GstAudioDecoder * dec)
|
|
{
|
|
gboolean result;
|
|
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), 0);
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
result = dec->priv->drainable;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_needs_format:
|
|
* @dec: a #GstAudioDecoder
|
|
* @enabled: new state
|
|
*
|
|
* Configures decoder format needs. If enabled, subclass needs to be
|
|
* negotiated with format caps before it can process any data. It will then
|
|
* never be handed any data before it has been configured.
|
|
* Otherwise, it might be handed data without having been configured and
|
|
* is then expected being able to do so either by default
|
|
* or based on the input data.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_needs_format (GstAudioDecoder * dec, gboolean enabled)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
dec->priv->needs_format = enabled;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_needs_format:
|
|
* @dec: a #GstAudioDecoder
|
|
*
|
|
* Queries decoder required format handling.
|
|
*
|
|
* Returns: TRUE if required format handling is enabled.
|
|
*
|
|
* MT safe.
|
|
*/
|
|
gboolean
|
|
gst_audio_decoder_get_needs_format (GstAudioDecoder * dec)
|
|
{
|
|
gboolean result;
|
|
|
|
g_return_val_if_fail (GST_IS_AUDIO_DECODER (dec), FALSE);
|
|
|
|
GST_OBJECT_LOCK (dec);
|
|
result = dec->priv->needs_format;
|
|
GST_OBJECT_UNLOCK (dec);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_merge_tags:
|
|
* @dec: a #GstAudioDecoder
|
|
* @tags: (allow-none): a #GstTagList to merge, or NULL
|
|
* @mode: the #GstTagMergeMode to use, usually #GST_TAG_MERGE_REPLACE
|
|
*
|
|
* Sets the audio decoder tags and how they should be merged with any
|
|
* upstream stream tags. This will override any tags previously-set
|
|
* with gst_audio_decoder_merge_tags().
|
|
*
|
|
* Note that this is provided for convenience, and the subclass is
|
|
* not required to use this and can still do tag handling on its own.
|
|
*/
|
|
void
|
|
gst_audio_decoder_merge_tags (GstAudioDecoder * dec,
|
|
const GstTagList * tags, GstTagMergeMode mode)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
g_return_if_fail (tags == NULL || GST_IS_TAG_LIST (tags));
|
|
g_return_if_fail (mode != GST_TAG_MERGE_UNDEFINED);
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
if (dec->priv->taglist != tags) {
|
|
if (dec->priv->taglist) {
|
|
gst_tag_list_unref (dec->priv->taglist);
|
|
dec->priv->taglist = NULL;
|
|
dec->priv->decoder_tags_merge_mode = GST_TAG_MERGE_KEEP_ALL;
|
|
}
|
|
if (tags) {
|
|
dec->priv->taglist = gst_tag_list_ref ((GstTagList *) tags);
|
|
dec->priv->decoder_tags_merge_mode = mode;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (dec, "setting decoder tags to %" GST_PTR_FORMAT, tags);
|
|
dec->priv->taglist_changed = TRUE;
|
|
}
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_allocate_output_buffer:
|
|
* @dec: a #GstAudioDecoder
|
|
* @size: size of the buffer
|
|
*
|
|
* Helper function that allocates a buffer to hold an audio frame
|
|
* for @dec's current output format.
|
|
*
|
|
* Returns: (transfer full): allocated buffer
|
|
*/
|
|
GstBuffer *
|
|
gst_audio_decoder_allocate_output_buffer (GstAudioDecoder * dec, gsize size)
|
|
{
|
|
GstBuffer *buffer = NULL;
|
|
gboolean needs_reconfigure = FALSE;
|
|
|
|
g_return_val_if_fail (size > 0, NULL);
|
|
|
|
GST_DEBUG ("alloc src buffer");
|
|
|
|
GST_AUDIO_DECODER_STREAM_LOCK (dec);
|
|
|
|
needs_reconfigure = gst_pad_check_reconfigure (dec->srcpad);
|
|
if (G_UNLIKELY (dec->priv->ctx.output_format_changed ||
|
|
(GST_AUDIO_INFO_IS_VALID (&dec->priv->ctx.info)
|
|
&& needs_reconfigure))) {
|
|
if (!gst_audio_decoder_negotiate_unlocked (dec)) {
|
|
GST_INFO_OBJECT (dec, "Failed to negotiate, fallback allocation");
|
|
gst_pad_mark_reconfigure (dec->srcpad);
|
|
goto fallback;
|
|
}
|
|
}
|
|
|
|
buffer =
|
|
gst_buffer_new_allocate (dec->priv->ctx.allocator, size,
|
|
&dec->priv->ctx.params);
|
|
if (!buffer) {
|
|
GST_INFO_OBJECT (dec, "couldn't allocate output buffer");
|
|
goto fallback;
|
|
}
|
|
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
return buffer;
|
|
fallback:
|
|
buffer = gst_buffer_new_allocate (NULL, size, NULL);
|
|
GST_AUDIO_DECODER_STREAM_UNLOCK (dec);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_get_allocator:
|
|
* @dec: a #GstAudioDecoder
|
|
* @allocator: (out) (allow-none) (transfer full): the #GstAllocator
|
|
* used
|
|
* @params: (out) (allow-none) (transfer full): the
|
|
* #GstAllocatorParams of @allocator
|
|
*
|
|
* Lets #GstAudioDecoder sub-classes to know the memory @allocator
|
|
* used by the base class and its @params.
|
|
*
|
|
* Unref the @allocator after use it.
|
|
*/
|
|
void
|
|
gst_audio_decoder_get_allocator (GstAudioDecoder * dec,
|
|
GstAllocator ** allocator, GstAllocationParams * params)
|
|
{
|
|
g_return_if_fail (GST_IS_AUDIO_DECODER (dec));
|
|
|
|
if (allocator)
|
|
*allocator = dec->priv->ctx.allocator ?
|
|
gst_object_ref (dec->priv->ctx.allocator) : NULL;
|
|
|
|
if (params)
|
|
*params = dec->priv->ctx.params;
|
|
}
|
|
|
|
/**
|
|
* gst_audio_decoder_set_use_default_pad_acceptcaps:
|
|
* @decoder: a #GstAudioDecoder
|
|
* @use: if the default pad accept-caps query handling should be used
|
|
*
|
|
* Lets #GstAudioDecoder sub-classes decide if they want the sink pad
|
|
* to use the default pad query handler to reply to accept-caps queries.
|
|
*
|
|
* By setting this to true it is possible to further customize the default
|
|
* handler with %GST_PAD_SET_ACCEPT_INTERSECT and
|
|
* %GST_PAD_SET_ACCEPT_TEMPLATE
|
|
*
|
|
* Since: 1.6
|
|
*/
|
|
void
|
|
gst_audio_decoder_set_use_default_pad_acceptcaps (GstAudioDecoder * decoder,
|
|
gboolean use)
|
|
{
|
|
decoder->priv->use_default_pad_acceptcaps = use;
|
|
}
|