FCL/sf/mw/gstreamer: comparison gst_plugins

equal deleted inserted replaced

-:567bb019e3e3
+:7e817e7e631c
 * Boston, MA 02111-1307, USA.
 */
 /**
 * SECTION:element-adder
 *
-* The adder allows to mix several streams into one by adding the data.
+* <refsect2>
+* <para>
+* The Adder allows to mix several streams into one by adding the data.
 * Mixed data is clamped to the min/max values of the data format.
-*
+* </para>
-* The adder currently mixes all data received on the sinkpads as soon as
-* possible without trying to synchronize the streams.
-*
-* <refsect2>
 * <title>Example launch line</title>
-* |[
+* <para>
+* <programlisting>
 * gst-launch audiotestsrc freq=100 ! adder name=mix ! audioconvert ! alsasink audiotestsrc freq=500 ! mix.
-* ]| This pipeline produces two sine waves mixed together.
+* </programlisting>
+* This pipeline produces two sine waves mixed together.
+* </para>
+* <para>
+* The Adder currently mixes all data received on the sinkpads as soon as possible
+* without trying to synchronize the streams.
+* </para>
 * </refsect2>
 *
 * Last reviewed on 2006-05-09 (0.10.7)
 */
 /* Element-Checklist-Version: 5 */
 #include "config.h"
 #endif
 #include "gstadder.h"
 #include <gst/audio/audio.h>
 #include <string.h>             /* strcmp */
-/*#include <liboil/liboil.h>*/
+#ifdef __SYMBIAN32__
+#include <glib_global.h>
+#endif
 /* highest positive/lowest negative x-bit value we can use for clamping */
 #define MAX_INT_32  ((gint32) (0x7fffffff))
 #define MAX_INT_16  ((gint16) (0x7fff))
 #define MAX_INT_8   ((gint8)  (0x7f))
 #define MIN_INT_8   ((gint8)  (0x80))
 #define MIN_UINT_32 ((guint32)(0x00000000))
 #define MIN_UINT_16 ((guint16)(0x0000))
 #define MIN_UINT_8  ((guint8) (0x00))
-enum
-{
-PROP_0,
-PROP_FILTER_CAPS
-};
 #define GST_CAT_DEFAULT gst_adder_debug
 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
 /* elementfactory information */
+static const GstElementDetails adder_details = GST_ELEMENT_DETAILS ("Adder",
-#define CAPS \
+"Generic/Audio",
-"audio/x-raw-int, " \
+"Add N audio channels together",
-"rate = (int) [ 1, MAX ], " \
+"Thomas <thomas@apestaart.org>");
-"channels = (int) [ 1, MAX ], " \
-"endianness = (int) BYTE_ORDER, " \
-"width = (int) 32, " \
-"depth = (int) 32, " \
-"signed = (boolean) { true, false } ;" \
-"audio/x-raw-int, " \
-"rate = (int) [ 1, MAX ], " \
-"channels = (int) [ 1, MAX ], " \
-"endianness = (int) BYTE_ORDER, " \
-"width = (int) 16, " \
-"depth = (int) 16, " \
-"signed = (boolean) { true, false } ;" \
-"audio/x-raw-int, " \
-"rate = (int) [ 1, MAX ], " \
-"channels = (int) [ 1, MAX ], " \
-"endianness = (int) BYTE_ORDER, " \
-"width = (int) 8, " \
-"depth = (int) 8, " \
-"signed = (boolean) { true, false } ;" \
-"audio/x-raw-float, " \
-"rate = (int) [ 1, MAX ], " \
-"channels = (int) [ 1, MAX ], " \
-"endianness = (int) BYTE_ORDER, " \
-"width = (int) { 32, 64 }"
 static GstStaticPadTemplate gst_adder_src_template =
 GST_STATIC_PAD_TEMPLATE ("src",
 GST_PAD_SRC,
 GST_PAD_ALWAYS,
-GST_STATIC_CAPS (CAPS)
+GST_STATIC_CAPS (GST_AUDIO_INT_PAD_TEMPLATE_CAPS "; "
+GST_AUDIO_FLOAT_PAD_TEMPLATE_CAPS)
 );
 static GstStaticPadTemplate gst_adder_sink_template =
 GST_STATIC_PAD_TEMPLATE ("sink%d",
 GST_PAD_SINK,
 GST_PAD_REQUEST,
-GST_STATIC_CAPS (CAPS)
+GST_STATIC_CAPS (GST_AUDIO_INT_PAD_TEMPLATE_CAPS "; "
+GST_AUDIO_FLOAT_PAD_TEMPLATE_CAPS)
 );
 static void gst_adder_class_init (GstAdderClass * klass);
 static void gst_adder_init (GstAdder * adder);
-static void gst_adder_dispose (GObject * object);
+static void gst_adder_finalize (GObject * object);
-static void gst_adder_set_property (GObject * object, guint prop_id,
-const GValue * value, GParamSpec * pspec);
-static void gst_adder_get_property (GObject * object, guint prop_id,
-GValue * value, GParamSpec * pspec);
 static gboolean gst_adder_setcaps (GstPad * pad, GstCaps * caps);
 static gboolean gst_adder_query (GstPad * pad, GstQuery * query);
 static gboolean gst_adder_src_event (GstPad * pad, GstEvent * event);
 static gboolean gst_adder_sink_event (GstPad * pad, GstEvent * event);
 "audio channel mixing element");
 }
 return adder_type;
 }
-/* clipping versions (for int)
+/* clipping versions */
-* FIXME: what about: oil_add_s16 (out, out, in, bytes / sizeof (type))
-*/
 #define MAKE_FUNC(name,type,ttype,min,max)                      \
 static void name (type *out, type *in, gint bytes) {            \
 gint i;                                                       \
-ttype add;                                                    \
+for (i = 0; i < bytes / sizeof (type); i++)                   \
-for (i = 0; i < bytes / sizeof (type); i++) {                 \
+out[i] = CLAMP ((ttype)out[i] + (ttype)in[i], min, max);    \
-add = (ttype)out[i] + (ttype)in[i];                         \
-out[i] = CLAMP (add, min, max);                             \
-}                                                             \
-}
-/* unsigned versions (for int) */
-#define MAKE_FUNC_US(name,type,ttype,max)                       \
-static void name (type *out, type *in, gint bytes) {            \
-gint i;                                                       \
-ttype add;                                                    \
-for (i = 0; i < bytes / sizeof (type); i++) {                 \
-add = (ttype)out[i] + (ttype)in[i];                         \
-out[i] = ((add <= max) ? add : max);                        \
-}                                                             \
 }
 /* non-clipping versions (for float) */
-#define MAKE_FUNC_NC(name,type)                                 \
+#define MAKE_FUNC_NC(name,type,ttype)                           \
 static void name (type *out, type *in, gint bytes) {            \
 gint i;                                                       \
 for (i = 0; i < bytes / sizeof (type); i++)                   \
-out[i] += in[i];                                            \
+out[i] = (ttype)out[i] + (ttype)in[i];                      \
 }
-#if 0
-/* right now, the liboil function don't seems to be faster on x86
-* time gst-launch audiotestsrc num-buffers=50000 ! audio/x-raw-float ! adder name=m ! fakesink audiotestsrc num-buffers=50000 ! audio/x-raw-float ! m.
-* time gst-launch audiotestsrc num-buffers=50000 ! audio/x-raw-float,width=32 ! adder name=m ! fakesink audiotestsrc num-buffers=50000 ! audio/x-raw-float,width=32 ! m.
-*/
-static void
-add_float32 (gfloat * out, gfloat * in, gint bytes)
-{
-oil_add_f32 (out, out, in, bytes / sizeof (gfloat));
-}
-static void
-add_float64 (gdouble * out, gdouble * in, gint bytes)
-{
-oil_add_f64 (out, out, in, bytes / sizeof (gdouble));
-}
-#endif
 /* *INDENT-OFF* */
 MAKE_FUNC (add_int32, gint32, gint64, MIN_INT_32, MAX_INT_32)
 MAKE_FUNC (add_int16, gint16, gint32, MIN_INT_16, MAX_INT_16)
 MAKE_FUNC (add_int8, gint8, gint16, MIN_INT_8, MAX_INT_8)
-MAKE_FUNC_US (add_uint32, guint32, guint64, MAX_UINT_32)
+MAKE_FUNC (add_uint32, guint32, guint64, MIN_UINT_32, MAX_UINT_32)
-MAKE_FUNC_US (add_uint16, guint16, guint32, MAX_UINT_16)
+MAKE_FUNC (add_uint16, guint16, guint32, MIN_UINT_16, MAX_UINT_16)
-MAKE_FUNC_US (add_uint8, guint8, guint16, MAX_UINT_8)
+MAKE_FUNC (add_uint8, guint8, guint16, MIN_UINT_8, MAX_UINT_8)
-MAKE_FUNC_NC (add_float64, gdouble)
+MAKE_FUNC_NC (add_float64, gdouble, gdouble)
-MAKE_FUNC_NC (add_float32, gfloat)
+MAKE_FUNC_NC (add_float32, gfloat, gfloat)
 /* *INDENT-ON* */
-/* we can only accept caps that we and downstream can handle.
+/* we can only accept caps that we and downstream can handle. */
-* if we have filtercaps set, use those to constrain the target caps.
-*/
 static GstCaps *
 gst_adder_sink_getcaps (GstPad * pad)
 {
 GstAdder *adder;
 GstCaps *result, *peercaps, *sinkcaps;
 adder = GST_ADDER (GST_PAD_PARENT (pad));
 GST_OBJECT_LOCK (adder);
 /* get the downstream possible caps */
 peercaps = gst_pad_peer_get_caps (adder->srcpad);
 /* get the allowed caps on this sinkpad, we use the fixed caps function so
 * that it does not call recursively in this function. */
 sinkcaps = gst_pad_get_fixed_caps_func (pad);
 if (peercaps) {
-/* restrict with filter-caps if any */
-if (adder->filter_caps) {
-result = gst_caps_intersect (peercaps, adder->filter_caps);
-gst_caps_unref (peercaps);
-peercaps = result;
-}
 /* if the peer has caps, intersect */
 GST_DEBUG_OBJECT (adder, "intersecting peer and template caps");
 result = gst_caps_intersect (peercaps, sinkcaps);
 gst_caps_unref (peercaps);
 gst_caps_unref (sinkcaps);
 GST_DEBUG_OBJECT (adder, "no peer caps, using sinkcaps");
 result = sinkcaps;
 }
 GST_OBJECT_UNLOCK (adder);
-GST_LOG_OBJECT (adder, "getting caps on pad %p,%s to %" GST_PTR_FORMAT, pad,
-GST_PAD_NAME (pad), result);
 return result;
 }
 /* the first caps we receive on any of the sinkpads will define the caps for all
 * the other sinkpads because we can only mix streams with the same caps.
-*/
+* */
 static gboolean
 gst_adder_setcaps (GstPad * pad, GstCaps * caps)
 {
 GstAdder *adder;
 GList *pads;
 /* parse caps now */
 structure = gst_caps_get_structure (caps, 0);
 media_type = gst_structure_get_name (structure);
 if (strcmp (media_type, "audio/x-raw-int") == 0) {
+GST_DEBUG_OBJECT (adder, "parse_caps sets adder to format int");
 adder->format = GST_ADDER_FORMAT_INT;
 gst_structure_get_int (structure, "width", &adder->width);
 gst_structure_get_int (structure, "depth", &adder->depth);
 gst_structure_get_int (structure, "endianness", &adder->endianness);
 gst_structure_get_boolean (structure, "signed", &adder->is_signed);
-GST_INFO_OBJECT (pad, "parse_caps sets adder to format int, %d bit",
-adder->width);
 if (adder->endianness != G_BYTE_ORDER)
 goto not_supported;
 switch (adder->width) {
 break;
 default:
 goto not_supported;
 }
 } else if (strcmp (media_type, "audio/x-raw-float") == 0) {
+GST_DEBUG_OBJECT (adder, "parse_caps sets adder to format float");
 adder->format = GST_ADDER_FORMAT_FLOAT;
 gst_structure_get_int (structure, "width", &adder->width);
-gst_structure_get_int (structure, "endianness", &adder->endianness);
-GST_INFO_OBJECT (pad, "parse_caps sets adder to format float, %d bit",
-adder->width);
-if (adder->endianness != G_BYTE_ORDER)
-goto not_supported;
 switch (adder->width) {
 case 32:
 adder->func = (GstAdderFunction) add_float32;
 break;
 done = FALSE;
 it = gst_element_iterate_sink_pads (GST_ELEMENT_CAST (adder));
 while (!done) {
 GstIteratorResult ires;
 gpointer item;
 ires = gst_iterator_next (it, &item);
 switch (ires) {
 case GST_ITERATOR_DONE:
 done = TRUE;
 break;
 case GST_ITERATOR_OK:
 {
 GstPad *pad = GST_PAD_CAST (item);
 gint64 duration;
 /* ask sink peer for duration */
 res &= gst_pad_query_peer_duration (pad, &format, &duration);
 /* take max from all valid return values */
 }
 /* else see if bigger than current max */
 else if (duration > max)
 max = duration;
 }
-gst_object_unref (pad);
 break;
 }
 case GST_ITERATOR_RESYNC:
 max = -1;
 res = TRUE;
-gst_iterator_resync (it);
 break;
 default:
 res = FALSE;
 done = TRUE;
 break;
 }
 gst_iterator_free (it);
 if (res) {
 /* and store the max */
-GST_DEBUG_OBJECT (adder, "Total duration in format %s: %"
-GST_TIME_FORMAT, gst_format_get_name (format), GST_TIME_ARGS (max));
 gst_query_set_duration (query, format, max);
-}
-return res;
-}
-static gboolean
-gst_adder_query_latency (GstAdder * adder, GstQuery * query)
-{
-GstClockTime min, max;
-gboolean live;
-gboolean res;
-GstIterator *it;
-gboolean done;
-res = TRUE;
-done = FALSE;
-live = FALSE;
-min = 0;
-max = GST_CLOCK_TIME_NONE;
-/* Take maximum of all latency values */
-it = gst_element_iterate_sink_pads (GST_ELEMENT_CAST (adder));
-while (!done) {
-GstIteratorResult ires;
-gpointer item;
-ires = gst_iterator_next (it, &item);
-switch (ires) {
-case GST_ITERATOR_DONE:
-done = TRUE;
-break;
-case GST_ITERATOR_OK:
-{
-GstPad *pad = GST_PAD_CAST (item);
-GstQuery *peerquery;
-GstClockTime min_cur, max_cur;
-gboolean live_cur;
-peerquery = gst_query_new_latency ();
-/* Ask peer for latency */
-res &= gst_pad_peer_query (pad, peerquery);
-/* take max from all valid return values */
-if (res) {
-gst_query_parse_latency (peerquery, &live_cur, &min_cur, &max_cur);
-if (min_cur > min)
-min = min_cur;
-if (max_cur != GST_CLOCK_TIME_NONE &&
-((max != GST_CLOCK_TIME_NONE && max_cur > max) ||
-(max == GST_CLOCK_TIME_NONE)))
-max = max_cur;
-live = live || live_cur;
-}
-gst_query_unref (peerquery);
-gst_object_unref (pad);
-break;
-}
-case GST_ITERATOR_RESYNC:
-live = FALSE;
-min = 0;
-max = GST_CLOCK_TIME_NONE;
-res = TRUE;
-gst_iterator_resync (it);
-break;
-default:
-res = FALSE;
-done = TRUE;
-break;
-}
-}
-gst_iterator_free (it);
-if (res) {
-/* store the results */
-GST_DEBUG_OBJECT (adder, "Calculated total latency: live %s, min %"
-GST_TIME_FORMAT ", max %" GST_TIME_FORMAT,
-(live ? "yes" : "no"), GST_TIME_ARGS (min), GST_TIME_ARGS (max));
-gst_query_set_latency (query, live, min, max);
 }
 return res;
 }
 break;
 }
 case GST_QUERY_DURATION:
 res = gst_adder_query_duration (adder, query);
 break;
-case GST_QUERY_LATENCY:
-res = gst_adder_query_latency (adder, query);
-break;
 default:
 /* FIXME, needs a custom query handler because we have multiple
 * sinkpads */
 res = gst_pad_query_default (pad, query);
 break;
 gst_object_unref (adder);
 return res;
 }
-typedef struct
-{
-GstEvent *event;
-gboolean flush;
-} EventData;
 static gboolean
-forward_event_func (GstPad * pad, GValue * ret, EventData * data)
+forward_event_func (GstPad * pad, GValue * ret, GstEvent * event)
 {
-GstEvent *event = data->event;
 gst_event_ref (event);
 GST_LOG_OBJECT (pad, "About to send event %s", GST_EVENT_TYPE_NAME (event));
 if (!gst_pad_push_event (pad, event)) {
 g_value_set_boolean (ret, FALSE);
 GST_WARNING_OBJECT (pad, "Sending event  %p (%s) failed.",
 event, GST_EVENT_TYPE_NAME (event));
-/* quick hack to unflush the pads, ideally we need a way to just unflush
-* this single collect pad */
-if (data->flush)
-gst_pad_send_event (pad, gst_event_new_flush_stop ());
 } else {
 GST_LOG_OBJECT (pad, "Sent event  %p (%s).",
 event, GST_EVENT_TYPE_NAME (event));
 }
 gst_object_unref (pad);
-/* continue on other pads, even if one failed */
 return TRUE;
 }
 /* forwards the event to all sinkpads, takes ownership of the
 * event
 *
 * Returns: TRUE if the event could be forwarded on all
 * sinkpads.
 */
 static gboolean
-forward_event (GstAdder * adder, GstEvent * event, gboolean flush)
+forward_event (GstAdder * adder, GstEvent * event)
 {
 gboolean ret;
 GstIterator *it;
-GstIteratorResult ires;
 GValue vret = { 0 };
-EventData data;
 GST_LOG_OBJECT (adder, "Forwarding event %p (%s)", event,
 GST_EVENT_TYPE_NAME (event));
 ret = TRUE;
-data.event = event;
-data.flush = flush;
 g_value_init (&vret, G_TYPE_BOOLEAN);
 g_value_set_boolean (&vret, TRUE);
 it = gst_element_iterate_sink_pads (GST_ELEMENT_CAST (adder));
-while (TRUE) {
+gst_iterator_fold (it, (GstIteratorFoldFunction) forward_event_func, &vret,
-ires = gst_iterator_fold (it, (GstIteratorFoldFunction) forward_event_func,
+event);
-&vret, &data);
-switch (ires) {
-case GST_ITERATOR_RESYNC:
-GST_WARNING ("resync");
-gst_iterator_resync (it);
-g_value_set_boolean (&vret, TRUE);
-break;
-case GST_ITERATOR_OK:
-case GST_ITERATOR_DONE:
-ret = g_value_get_boolean (&vret);
-goto done;
-default:
-ret = FALSE;
-goto done;
-}
-}
-done:
 gst_iterator_free (it);
-GST_LOG_OBJECT (adder, "Forwarded event %p (%s), ret=%d", event,
-GST_EVENT_TYPE_NAME (event), ret);
 gst_event_unref (event);
+ret = g_value_get_boolean (&vret);
 return ret;
 }
 static gboolean
 gboolean result;
 adder = GST_ADDER (gst_pad_get_parent (pad));
 switch (GST_EVENT_TYPE (event)) {
+case GST_EVENT_QOS:
+/* QoS might be tricky */
+result = FALSE;
+break;
 case GST_EVENT_SEEK:
 {
 GstSeekFlags flags;
 GstSeekType curtype;
 gint64 cur;
-gboolean flush;
 /* parse the seek parameters */
 gst_event_parse_seek (event, &adder->segment_rate, NULL, &flags, &curtype,
 &cur, NULL, NULL);
-flush = (flags & GST_SEEK_FLAG_FLUSH) == GST_SEEK_FLAG_FLUSH;
 /* check if we are flushing */
-if (flush) {
+if (flags & GST_SEEK_FLAG_FLUSH) {
 /* make sure we accept nothing anymore and return WRONG_STATE */
 gst_collect_pads_set_flushing (adder->collect, TRUE);
 /* flushing seek, start flush downstream, the flush will be done
 * when all pads received a FLUSH_STOP. */
 gst_pad_push_event (adder->srcpad, gst_event_new_flush_start ());
 }
-GST_DEBUG_OBJECT (adder, "handling seek event: %" GST_PTR_FORMAT, event);
 /* now wait for the collected to be finished and mark a new
-* segment. After we have the lock, no collect function is running and no
+* segment */
-* new collect function will be called for as long as we're flushing. */
 GST_OBJECT_LOCK (adder->collect);
 if (curtype == GST_SEEK_TYPE_SET)
 adder->segment_position = cur;
 else
 adder->segment_position = 0;
-/* make sure we push a new segment, to inform about new basetime
-* see FIXME in gst_adder_collected() */
 adder->segment_pending = TRUE;
-if (flush) {
-/* Yes, we need to call _set_flushing again *WHEN* the streaming threads
-* have stopped so that the cookie gets properly updated. */
-gst_collect_pads_set_flushing (adder->collect, TRUE);
-}
-/* we might have a pending flush_stop event now. This event will either be
-* sent by an upstream element when it completes the seek or we will push
-* one in the collected callback ourself */
-adder->flush_stop_pending = flush;
 GST_OBJECT_UNLOCK (adder->collect);
-GST_DEBUG_OBJECT (adder, "forwarding seek event: %" GST_PTR_FORMAT,
-event);
+result = forward_event (adder, event);
-result = forward_event (adder, event, flush);
-if (!result) {
-/* seek failed. maybe source is a live source. */
-GST_DEBUG_OBJECT (adder, "seeking failed");
-}
-/* FIXME: ideally we would like to send a flush-stop event from here but
-* collectpads does not have a method that allows us to do that. Instead
-* we forward all flush-stop events we receive on the sinkpads. We might
-* be sending too many flush-stop events. */
 break;
 }
-case GST_EVENT_QOS:
-/* QoS might be tricky */
-result = FALSE;
-break;
 case GST_EVENT_NAVIGATION:
 /* navigation is rather pointless. */
 result = FALSE;
 break;
 default:
 /* just forward the rest for now */
-GST_DEBUG_OBJECT (adder, "forward unhandled event: %s",
+result = forward_event (adder, event);
-GST_EVENT_TYPE_NAME (event));
-result = forward_event (adder, event, FALSE);
 break;
 }
 gst_object_unref (adder);
 return result;
 static gboolean
 gst_adder_sink_event (GstPad * pad, GstEvent * event)
 {
 GstAdder *adder;
-gboolean ret = TRUE;
+gboolean ret;
 adder = GST_ADDER (gst_pad_get_parent (pad));
 GST_DEBUG ("Got %s event on pad %s:%s", GST_EVENT_TYPE_NAME (event),
 GST_DEBUG_PAD_NAME (pad));
 switch (GST_EVENT_TYPE (event)) {
 case GST_EVENT_FLUSH_STOP:
-/* we received a flush-stop. The collect_event function will push the
+/* mark a pending new segment. This event is synchronized
-* event past our element. We simply forward all flush-stop events, even
+* with the streaming thread so we can safely update the
-* when no flush-stop was pendingk, this is required because collectpads
+* variable without races. It's somewhat weird because we
-* does not provide an API to handle-but-not-forward the flush-stop.
+* assume the collectpads forwarded the FLUSH_STOP past us
-* We unset the pending flush-stop flag so that we don't send anymore
+* and downstream (using our source pad, the bastard!).
-* flush-stop from the collect function later.
 */
-GST_OBJECT_LOCK (adder->collect);
 adder->segment_pending = TRUE;
-adder->flush_stop_pending = FALSE;
+break;
-/* Clear pending tags */
-if (adder->pending_events) {
-g_list_foreach (adder->pending_events, (GFunc) gst_event_unref, NULL);
-g_list_free (adder->pending_events);
-adder->pending_events = NULL;
-}
-GST_OBJECT_UNLOCK (adder->collect);
-break;
-case GST_EVENT_TAG:
-GST_OBJECT_LOCK (adder->collect);
-/* collectpads is a pile of horse manure. */
-adder->pending_events = g_list_append (adder->pending_events, event);
-GST_OBJECT_UNLOCK (adder->collect);
-goto beach;
 default:
 break;
 }
 /* now GstCollectPads can take care of the rest, e.g. EOS */
 ret = adder->collect_event (pad, event);
-beach:
 gst_object_unref (adder);
 return ret;
 }
 static void
 gst_adder_class_init (GstAdderClass * klass)
 {
-GObjectClass *gobject_class = (GObjectClass *) klass;
+GObjectClass *gobject_class;
-GstElementClass *gstelement_class = (GstElementClass *) klass;
+GstElementClass *gstelement_class;
-gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_adder_set_property);
+gobject_class = (GObjectClass *) klass;
-gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_adder_get_property);
-gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_adder_dispose);
+gobject_class->finalize = gst_adder_finalize;
+gstelement_class = (GstElementClass *) klass;
 gst_element_class_add_pad_template (gstelement_class,
 gst_static_pad_template_get (&gst_adder_src_template));
 gst_element_class_add_pad_template (gstelement_class,
 gst_static_pad_template_get (&gst_adder_sink_template));
-gst_element_class_set_details_simple (gstelement_class, "Adder",
+gst_element_class_set_details (gstelement_class, &adder_details);
-"Generic/Audio",
-"Add N audio channels together",
-"Thomas Vander Stichele <thomas at apestaart dot org>");
 parent_class = g_type_class_peek_parent (klass);
-/**
+gstelement_class->request_new_pad = gst_adder_request_new_pad;
-* GstAdder:caps:
+gstelement_class->release_pad = gst_adder_release_pad;
-*
+gstelement_class->change_state = gst_adder_change_state;
-* Since: 0.10.24
-*/
-g_object_class_install_property (gobject_class, PROP_FILTER_CAPS,
-g_param_spec_boxed ("caps", "Target caps",
-"Set target format for mixing (NULL means ANY). "
-"Setting this property takes a reference to the supplied GstCaps "
-"object.", GST_TYPE_CAPS,
-G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
-gstelement_class->request_new_pad =
-GST_DEBUG_FUNCPTR (gst_adder_request_new_pad);
-gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_adder_release_pad);
-gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_adder_change_state);
 }
 static void
 gst_adder_init (GstAdder * adder)
 {
 GstPadTemplate *template;
 template = gst_static_pad_template_get (&gst_adder_src_template);
 adder->srcpad = gst_pad_new_from_template (template, "src");
 gst_object_unref (template);
 gst_pad_set_getcaps_function (adder->srcpad,
 GST_DEBUG_FUNCPTR (gst_pad_proxy_getcaps));
 gst_pad_set_setcaps_function (adder->srcpad,
 GST_DEBUG_FUNCPTR (gst_adder_setcaps));
 gst_pad_set_query_function (adder->srcpad,
 adder->format = GST_ADDER_FORMAT_UNSET;
 adder->padcount = 0;
 adder->func = NULL;
-adder->filter_caps = gst_caps_new_any ();
 /* keep track of the sinkpads requested */
 adder->collect = gst_collect_pads_new ();
 gst_collect_pads_set_function (adder->collect,
 GST_DEBUG_FUNCPTR (gst_adder_collected), adder);
 }
 static void
-gst_adder_dispose (GObject * object)
+gst_adder_finalize (GObject * object)
 {
 GstAdder *adder = GST_ADDER (object);
-if (adder->collect) {
+gst_object_unref (adder->collect);
-gst_object_unref (adder->collect);
+adder->collect = NULL;
-adder->collect = NULL;
-}
+G_OBJECT_CLASS (parent_class)->finalize (object);
-gst_caps_replace (&adder->filter_caps, NULL);
+}
-if (adder->pending_events) {
-g_list_foreach (adder->pending_events, (GFunc) gst_event_unref, NULL);
-g_list_free (adder->pending_events);
-adder->pending_events = NULL;
-}
-G_OBJECT_CLASS (parent_class)->dispose (object);
-}
-static void
-gst_adder_set_property (GObject * object, guint prop_id,
-const GValue * value, GParamSpec * pspec)
-{
-GstAdder *adder = GST_ADDER (object);
-switch (prop_id) {
-case PROP_FILTER_CAPS:{
-GstCaps *new_caps;
-GstCaps *old_caps;
-const GstCaps *new_caps_val = gst_value_get_caps (value);
-if (new_caps_val == NULL) {
-new_caps = gst_caps_new_any ();
-} else {
-new_caps = (GstCaps *) new_caps_val;
-gst_caps_ref (new_caps);
-}
-GST_OBJECT_LOCK (adder);
-old_caps = adder->filter_caps;
-adder->filter_caps = new_caps;
-GST_OBJECT_UNLOCK (adder);
-gst_caps_unref (old_caps);
-GST_DEBUG_OBJECT (adder, "set new caps %" GST_PTR_FORMAT, new_caps);
-break;
-}
-default:
-G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-break;
-}
-}
-static void
-gst_adder_get_property (GObject * object, guint prop_id, GValue * value,
-GParamSpec * pspec)
-{
-GstAdder *adder = GST_ADDER (object);
-switch (prop_id) {
-case PROP_FILTER_CAPS:
-GST_OBJECT_LOCK (adder);
-gst_value_set_caps (value, adder->filter_caps);
-GST_OBJECT_UNLOCK (adder);
-break;
-default:
-G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-break;
-}
-}
 static GstPad *
 gst_adder_request_new_pad (GstElement * element, GstPadTemplate * templ,
 const gchar * unused)
 {
 static GstFlowReturn
 gst_adder_collected (GstCollectPads * pads, gpointer user_data)
 {
 /*
-* combine streams by adding data values
+* combine channels by adding sample values
 * basic algorithm :
 * - this function is called when all pads have a buffer
 * - get available bytes on all pads.
 * - repeat for each input pad :
 *   - read available bytes, copy or add to target buffer
 *   - if there's an EOS event, remove the input channel
 * - push out the output buffer
-*
-* todo:
-* - would be nice to have a mixing mode, where instead of adding we mix
-*   - for float we could downscale after collect loop
-*   - for int we need to downscale each input to avoid clipping or
-*     mix into a temp (float) buffer and scale afterwards as well
 */
 GstAdder *adder;
+guint size;
 GSList *collected;
+GstBuffer *outbuf;
 GstFlowReturn ret;
-GstBuffer *outbuf = NULL;
+gpointer outbytes;
-gpointer outdata = NULL;
-guint outsize;
 gboolean empty = TRUE;
 adder = GST_ADDER (user_data);
 /* this is fatal */
 if (G_UNLIKELY (adder->func == NULL))
 goto not_negotiated;
-if (adder->flush_stop_pending) {
+/* get available bytes for reading, this can be 0 which could mean
-gst_pad_push_event (adder->srcpad, gst_event_new_flush_stop ());
+* empty buffers or EOS, which we will catch when we loop over the
-adder->flush_stop_pending = FALSE;
+* pads. */
-}
+size = gst_collect_pads_available (pads);
-/* get available bytes for reading, this can be 0 which could mean empty
-* buffers or EOS, which we will catch when we loop over the pads. */
-outsize = gst_collect_pads_available (pads);
 GST_LOG_OBJECT (adder,
-"starting to cycle through channels, %d bytes available (bps = %d)",
+"starting to cycle through channels, %d bytes available (bps = %d)", size,
-outsize, adder->bps);
+adder->bps);
+outbuf = NULL;
+outbytes = NULL;
 for (collected = pads->data; collected; collected = g_slist_next (collected)) {
-GstCollectData *collect_data;
+GstCollectData *data;
+guint8 *bytes;
+guint len;
 GstBuffer *inbuf;
-guint8 *indata;
-guint insize;
+data = (GstCollectData *) collected->data;
-collect_data = (GstCollectData *) collected->data;
 /* get a subbuffer of size bytes */
-inbuf = gst_collect_pads_take_buffer (pads, collect_data, outsize);
+inbuf = gst_collect_pads_take_buffer (pads, data, size);
 /* NULL means EOS or an empty buffer so we still need to flush in
 * case of an empty buffer. */
 if (inbuf == NULL) {
-GST_LOG_OBJECT (adder, "channel %p: no bytes available", collect_data);
+GST_LOG_OBJECT (adder, "channel %p: no bytes available", data);
-continue;
+goto next;
 }
-indata = GST_BUFFER_DATA (inbuf);
+bytes = GST_BUFFER_DATA (inbuf);
-insize = GST_BUFFER_SIZE (inbuf);
+len = GST_BUFFER_SIZE (inbuf);
 if (outbuf == NULL) {
 GST_LOG_OBJECT (adder, "channel %p: making output buffer of %d bytes",
-collect_data, outsize);
+data, size);
-/* first buffer, alloc outsize.
+/* first buffer, alloc size bytes. FIXME, we can easily subbuffer
-* FIXME: we can easily subbuffer and _make_writable.
+* and _make_writable. */
-* FIXME: only create empty buffer for first non-gap buffer, so that we
+outbuf = gst_buffer_new_and_alloc (size);
-* only use adder function when really adding
+outbytes = GST_BUFFER_DATA (outbuf);
-*/
-outbuf = gst_buffer_new_and_alloc (outsize);
-outdata = GST_BUFFER_DATA (outbuf);
 gst_buffer_set_caps (outbuf, GST_PAD_CAPS (adder->srcpad));
 if (!GST_BUFFER_FLAG_IS_SET (inbuf, GST_BUFFER_FLAG_GAP)) {
+/* clear if we are only going to fill a partial buffer */
+if (G_UNLIKELY (size > len))
+memset (outbytes, 0, size);
 GST_LOG_OBJECT (adder, "channel %p: copying %d bytes from data %p",
-collect_data, insize, indata);
+data, len, bytes);
-/* clear if we are only going to fill a partial buffer */
-if (G_UNLIKELY (outsize > insize))
-memset ((guint8 *) outdata + insize, 0, outsize - insize);
 /* and copy the data into it */
-memcpy (outdata, indata, insize);
+memcpy (outbytes, bytes, len);
 empty = FALSE;
 } else {
-/* clear whole buffer */
 GST_LOG_OBJECT (adder, "channel %p: zeroing %d bytes from data %p",
-collect_data, insize, indata);
+data, len, bytes);
-memset (outdata, 0, outsize);
+memset (outbytes, 0, size);
 }
 } else {
 if (!GST_BUFFER_FLAG_IS_SET (inbuf, GST_BUFFER_FLAG_GAP)) {
 GST_LOG_OBJECT (adder, "channel %p: mixing %d bytes from data %p",
-collect_data, insize, indata);
+data, len, bytes);
-/* further buffers, need to add them */
+/* other buffers, need to add them */
-adder->func ((gpointer) outdata, (gpointer) indata, insize);
+adder->func ((gpointer) outbytes, (gpointer) bytes, len);
 empty = FALSE;
 } else {
 GST_LOG_OBJECT (adder, "channel %p: skipping %d bytes from data %p",
-collect_data, insize, indata);
+data, len, bytes);
 }
 }
-gst_buffer_unref (inbuf);
+next:
+if (inbuf)
+gst_buffer_unref (inbuf);
 }
 /* can only happen when no pads to collect or all EOS */
 if (outbuf == NULL)
 goto eos;
 * match.
 */
 event = gst_event_new_new_segment_full (FALSE, adder->segment_rate,
 1.0, GST_FORMAT_TIME, adder->timestamp, -1, adder->segment_position);
-if (event) {
+gst_pad_push_event (adder->srcpad, event);
-if (!gst_pad_push_event (adder->srcpad, event)) {
+adder->segment_pending = FALSE;
-GST_WARNING_OBJECT (adder->srcpad, "Sending event  %p (%s) failed.",
+adder->segment_position = 0;
-event, GST_EVENT_TYPE_NAME (event));
-}
-adder->segment_pending = FALSE;
-adder->segment_position = 0;
-} else {
-GST_WARNING_OBJECT (adder->srcpad, "Creating new segment event for "
-"start:%" G_GINT64_FORMAT "  pos:%" G_GINT64_FORMAT " failed",
-adder->timestamp, adder->segment_position);
-}
-}
-if (G_UNLIKELY (adder->pending_events)) {
-GList *tmp = adder->pending_events;
-while (tmp) {
-GstEvent *ev = (GstEvent *) tmp->data;
-gst_pad_push_event (adder->srcpad, ev);
-tmp = g_list_next (tmp);
-}
-g_list_free (adder->pending_events);
-adder->pending_events = NULL;
 }
 /* set timestamps on the output buffer */
 GST_BUFFER_TIMESTAMP (outbuf) = adder->timestamp;
 GST_BUFFER_OFFSET (outbuf) = adder->offset;
 /* for the next timestamp, use the sample counter, which will
 * never accumulate rounding errors */
-adder->offset += outsize / adder->bps;
+adder->offset += size / adder->bps;
 adder->timestamp = gst_util_uint64_scale_int (adder->offset,
 GST_SECOND, adder->rate);
 /* now we can set the duration of the buffer */
 GST_BUFFER_DURATION (outbuf) = adder->timestamp -
 /* send it out */
 GST_LOG_OBJECT (adder, "pushing outbuf, timestamp %" GST_TIME_FORMAT,
 GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)));
 ret = gst_pad_push (adder->srcpad, outbuf);
-GST_LOG_OBJECT (adder, "pushed outbuf, result = %s", gst_flow_get_name (ret));
 return ret;
 /* ERRORS */
 not_negotiated:
 case GST_STATE_CHANGE_NULL_TO_READY:
 break;
 case GST_STATE_CHANGE_READY_TO_PAUSED:
 adder->timestamp = 0;
 adder->offset = 0;
-adder->flush_stop_pending = FALSE;
 adder->segment_pending = TRUE;
 adder->segment_position = 0;
 adder->segment_rate = 1.0;
 gst_segment_init (&adder->segment, GST_FORMAT_UNDEFINED);
 gst_collect_pads_start (adder->collect);
 static gboolean
 plugin_init (GstPlugin * plugin)
 {
-/*oil_init (); */
 if (!gst_element_register (plugin, "adder", GST_RANK_NONE, GST_TYPE_ADDER)) {
 return FALSE;
 }
 return TRUE;

branch	RCL_3
changeset 30	7e817e7e631c
parent 29	567bb019e3e3