f90d75193ecb1364ca8167e10ffa36ccbb945262
[platform/upstream/gstreamer.git] / libs / gst / base / gstbasetransform.c
1 /* GStreamer
2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3  *                    2005 Wim Taymans <wim@fluendo.com>
4  *                    2005 Andy Wingo <wingo@fluendo.com>
5  *                    2005 Thomas Vander Stichele <thomas at apestaart dot org>
6  *                    2008 Wim Taymans <wim.taymans@gmail.com>
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License along with this library; if not, write to the
20  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 /**
25  * SECTION:gstbasetransform
26  * @title: GstBaseTransform
27  * @short_description: Base class for simple transform filters
28  * @see_also: #GstBaseSrc, #GstBaseSink
29  *
30  * This base class is for filter elements that process data. Elements
31  * that are suitable for implementation using #GstBaseTransform are ones
32  * where the size and caps of the output is known entirely from the input
33  * caps and buffer sizes. These include elements that directly transform
34  * one buffer into another, modify the contents of a buffer in-place, as
35  * well as elements that collate multiple input buffers into one output buffer,
36  * or that expand one input buffer into multiple output buffers. See below
37  * for more concrete use cases.
38  *
39  * It provides for:
40  *
41  * * one sinkpad and one srcpad
42  * * Possible formats on sink and source pad implemented
43  *   with custom transform_caps function. By default uses
44  *   same format on sink and source.
45  *
46  * * Handles state changes
47  * * Does flushing
48  * * Push mode
49  * * Pull mode if the sub-class transform can operate on arbitrary data
50  *
51  * # Use Cases
52  *
53  * ## Passthrough mode
54  *
55  *   * Element has no interest in modifying the buffer. It may want to inspect it,
56  *     in which case the element should have a transform_ip function. If there
57  *     is no transform_ip function in passthrough mode, the buffer is pushed
58  *     intact.
59  *
60  *   * The #GstBaseTransformClass.passthrough_on_same_caps variable
61  *     will automatically set/unset passthrough based on whether the
62  *     element negotiates the same caps on both pads.
63  *
64  *   * #GstBaseTransformClass.passthrough_on_same_caps on an element that
65  *     doesn't implement a transform_caps function is useful for elements that
66  *     only inspect data (such as level)
67  *
68  *   * Example elements
69  *
70  *     * Level
71  *     * Videoscale, audioconvert, videoconvert, audioresample in certain modes.
72  *
73  * ## Modifications in-place - input buffer and output buffer are the same thing.
74  *
75  * * The element must implement a transform_ip function.
76  * * Output buffer size must <= input buffer size
77  * * If the always_in_place flag is set, non-writable buffers will be copied
78  *   and passed to the transform_ip function, otherwise a new buffer will be
79  *   created and the transform function called.
80  *
81  * * Incoming writable buffers will be passed to the transform_ip function
82  *   immediately.
83  * * only implementing transform_ip and not transform implies always_in_place = %TRUE
84  *
85  *   * Example elements:
86  *     * Volume
87  *     * Audioconvert in certain modes (signed/unsigned conversion)
88  *     * videoconvert in certain modes (endianness swapping)
89  *
90  * ## Modifications only to the caps/metadata of a buffer
91  *
92  * * The element does not require writable data, but non-writable buffers
93  *   should be subbuffered so that the meta-information can be replaced.
94  *
95  * * Elements wishing to operate in this mode should replace the
96  *   prepare_output_buffer method to create subbuffers of the input buffer
97  *   and set always_in_place to %TRUE
98  *
99  * * Example elements
100  *   * Capsfilter when setting caps on outgoing buffers that have
101  *     none.
102  *   * identity when it is going to re-timestamp buffers by
103  *     datarate.
104  *
105  * ## Normal mode
106  *   * always_in_place flag is not set, or there is no transform_ip function
107  *   * Element will receive an input buffer and output buffer to operate on.
108  *   * Output buffer is allocated by calling the prepare_output_buffer function.
109  *   * Example elements:
110  *     * Videoscale, videoconvert, audioconvert when doing
111  *     scaling/conversions
112  *
113  * ## Special output buffer allocations
114  *   * Elements which need to do special allocation of their output buffers
115  *     beyond allocating output buffers via the negotiated allocator or
116  *     buffer pool should implement the prepare_output_buffer method.
117  *
118  *   * Example elements:
119  *     * efence
120  *
121  * # Sub-class settable flags on GstBaseTransform
122  *
123  * * passthrough
124  *
125  *   * Implies that in the current configuration, the sub-class is not interested in modifying the buffers.
126  *   * Elements which are always in passthrough mode whenever the same caps has been negotiated on both pads can set the class variable passthrough_on_same_caps to have this behaviour automatically.
127  *
128  * * always_in_place
129  *   * Determines whether a non-writable buffer will be copied before passing
130  *     to the transform_ip function.
131  *
132  *   * Implied %TRUE if no transform function is implemented.
133  *   * Implied %FALSE if ONLY transform function is implemented.
134  */
135
136 #ifdef HAVE_CONFIG_H
137 #  include "config.h"
138 #endif
139
140 #include <stdlib.h>
141 #include <string.h>
142
143 #include "../../../gst/gst_private.h"
144 #include "../../../gst/gst-i18n-lib.h"
145 #include "../../../gst/glib-compat-private.h"
146 #include "gstbasetransform.h"
147
148 GST_DEBUG_CATEGORY_STATIC (gst_base_transform_debug);
149 #define GST_CAT_DEFAULT gst_base_transform_debug
150
151 /* BaseTransform signals and args */
152 enum
153 {
154   /* FILL ME */
155   LAST_SIGNAL
156 };
157
158 #define DEFAULT_PROP_QOS        FALSE
159
160 enum
161 {
162   PROP_0,
163   PROP_QOS
164 };
165
166 #define GST_BASE_TRANSFORM_GET_PRIVATE(obj)  \
167     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_TRANSFORM, GstBaseTransformPrivate))
168
169 struct _GstBaseTransformPrivate
170 {
171   /* Set by sub-class */
172   gboolean passthrough;
173   gboolean always_in_place;
174
175   GstCaps *cache_caps1;
176   gsize cache_caps1_size;
177   GstCaps *cache_caps2;
178   gsize cache_caps2_size;
179   gboolean have_same_caps;
180
181   gboolean negotiated;
182
183   /* QoS *//* with LOCK */
184   gboolean qos_enabled;
185   gdouble proportion;
186   GstClockTime earliest_time;
187   /* previous buffer had a discont */
188   gboolean discont;
189
190   GstPadMode pad_mode;
191
192   gboolean gap_aware;
193   gboolean prefer_passthrough;
194
195   /* QoS stats */
196   guint64 processed;
197   guint64 dropped;
198
199   GstClockTime position_out;
200
201   GstBufferPool *pool;
202   gboolean pool_active;
203   GstAllocator *allocator;
204   GstAllocationParams params;
205   GstQuery *query;
206 };
207
208
209 static GstElementClass *parent_class = NULL;
210
211 static void gst_base_transform_class_init (GstBaseTransformClass * klass);
212 static void gst_base_transform_init (GstBaseTransform * trans,
213     GstBaseTransformClass * klass);
214 static GstFlowReturn default_submit_input_buffer (GstBaseTransform * trans,
215     gboolean is_discont, GstBuffer * input);
216 static GstFlowReturn default_generate_output (GstBaseTransform * trans,
217     GstBuffer ** outbuf);
218
219 /* we can't use G_DEFINE_ABSTRACT_TYPE because we need the klass in the _init
220  * method to get to the padtemplates */
221 GType
222 gst_base_transform_get_type (void)
223 {
224   static volatile gsize base_transform_type = 0;
225
226   if (g_once_init_enter (&base_transform_type)) {
227     GType _type;
228     static const GTypeInfo base_transform_info = {
229       sizeof (GstBaseTransformClass),
230       NULL,
231       NULL,
232       (GClassInitFunc) gst_base_transform_class_init,
233       NULL,
234       NULL,
235       sizeof (GstBaseTransform),
236       0,
237       (GInstanceInitFunc) gst_base_transform_init,
238     };
239
240     _type = g_type_register_static (GST_TYPE_ELEMENT,
241         "GstBaseTransform", &base_transform_info, G_TYPE_FLAG_ABSTRACT);
242     g_once_init_leave (&base_transform_type, _type);
243   }
244   return base_transform_type;
245 }
246
247 static void gst_base_transform_finalize (GObject * object);
248 static void gst_base_transform_set_property (GObject * object, guint prop_id,
249     const GValue * value, GParamSpec * pspec);
250 static void gst_base_transform_get_property (GObject * object, guint prop_id,
251     GValue * value, GParamSpec * pspec);
252 static gboolean gst_base_transform_src_activate_mode (GstPad * pad,
253     GstObject * parent, GstPadMode mode, gboolean active);
254 static gboolean gst_base_transform_sink_activate_mode (GstPad * pad,
255     GstObject * parent, GstPadMode mode, gboolean active);
256 static gboolean gst_base_transform_activate (GstBaseTransform * trans,
257     gboolean active);
258 static gboolean gst_base_transform_get_unit_size (GstBaseTransform * trans,
259     GstCaps * caps, gsize * size);
260
261 static gboolean gst_base_transform_src_event (GstPad * pad, GstObject * parent,
262     GstEvent * event);
263 static gboolean gst_base_transform_src_eventfunc (GstBaseTransform * trans,
264     GstEvent * event);
265 static gboolean gst_base_transform_sink_event (GstPad * pad, GstObject * parent,
266     GstEvent * event);
267 static gboolean gst_base_transform_sink_eventfunc (GstBaseTransform * trans,
268     GstEvent * event);
269 static GstFlowReturn gst_base_transform_getrange (GstPad * pad,
270     GstObject * parent, guint64 offset, guint length, GstBuffer ** buffer);
271 static GstFlowReturn gst_base_transform_chain (GstPad * pad, GstObject * parent,
272     GstBuffer * buffer);
273 static GstCaps *gst_base_transform_default_transform_caps (GstBaseTransform *
274     trans, GstPadDirection direction, GstCaps * caps, GstCaps * filter);
275 static GstCaps *gst_base_transform_default_fixate_caps (GstBaseTransform *
276     trans, GstPadDirection direction, GstCaps * caps, GstCaps * othercaps);
277 static GstCaps *gst_base_transform_query_caps (GstBaseTransform * trans,
278     GstPad * pad, GstCaps * filter);
279 static gboolean gst_base_transform_acceptcaps_default (GstBaseTransform * trans,
280     GstPadDirection direction, GstCaps * caps);
281 static gboolean gst_base_transform_setcaps (GstBaseTransform * trans,
282     GstPad * pad, GstCaps * caps);
283 static gboolean gst_base_transform_default_decide_allocation (GstBaseTransform
284     * trans, GstQuery * query);
285 static gboolean gst_base_transform_default_propose_allocation (GstBaseTransform
286     * trans, GstQuery * decide_query, GstQuery * query);
287 static gboolean gst_base_transform_query (GstPad * pad, GstObject * parent,
288     GstQuery * query);
289 static gboolean gst_base_transform_default_query (GstBaseTransform * trans,
290     GstPadDirection direction, GstQuery * query);
291 static gboolean gst_base_transform_default_transform_size (GstBaseTransform *
292     trans, GstPadDirection direction, GstCaps * caps, gsize size,
293     GstCaps * othercaps, gsize * othersize);
294
295 static GstFlowReturn default_prepare_output_buffer (GstBaseTransform * trans,
296     GstBuffer * inbuf, GstBuffer ** outbuf);
297 static gboolean default_copy_metadata (GstBaseTransform * trans,
298     GstBuffer * inbuf, GstBuffer * outbuf);
299 static gboolean
300 gst_base_transform_default_transform_meta (GstBaseTransform * trans,
301     GstBuffer * inbuf, GstMeta * meta, GstBuffer * outbuf);
302
303 /* static guint gst_base_transform_signals[LAST_SIGNAL] = { 0 }; */
304
305
306 static void
307 gst_base_transform_finalize (GObject * object)
308 {
309   G_OBJECT_CLASS (parent_class)->finalize (object);
310 }
311
312 static void
313 gst_base_transform_class_init (GstBaseTransformClass * klass)
314 {
315   GObjectClass *gobject_class;
316
317   gobject_class = G_OBJECT_CLASS (klass);
318
319   GST_DEBUG_CATEGORY_INIT (gst_base_transform_debug, "basetransform", 0,
320       "basetransform element");
321
322   GST_DEBUG ("gst_base_transform_class_init");
323
324   g_type_class_add_private (klass, sizeof (GstBaseTransformPrivate));
325
326   parent_class = g_type_class_peek_parent (klass);
327
328   gobject_class->set_property = gst_base_transform_set_property;
329   gobject_class->get_property = gst_base_transform_get_property;
330
331   g_object_class_install_property (gobject_class, PROP_QOS,
332       g_param_spec_boolean ("qos", "QoS", "Handle Quality-of-Service events",
333           DEFAULT_PROP_QOS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
334
335   gobject_class->finalize = gst_base_transform_finalize;
336
337   klass->passthrough_on_same_caps = FALSE;
338   klass->transform_ip_on_passthrough = TRUE;
339
340   klass->transform_caps =
341       GST_DEBUG_FUNCPTR (gst_base_transform_default_transform_caps);
342   klass->fixate_caps =
343       GST_DEBUG_FUNCPTR (gst_base_transform_default_fixate_caps);
344   klass->accept_caps =
345       GST_DEBUG_FUNCPTR (gst_base_transform_acceptcaps_default);
346   klass->query = GST_DEBUG_FUNCPTR (gst_base_transform_default_query);
347   klass->decide_allocation =
348       GST_DEBUG_FUNCPTR (gst_base_transform_default_decide_allocation);
349   klass->propose_allocation =
350       GST_DEBUG_FUNCPTR (gst_base_transform_default_propose_allocation);
351   klass->transform_size =
352       GST_DEBUG_FUNCPTR (gst_base_transform_default_transform_size);
353   klass->transform_meta =
354       GST_DEBUG_FUNCPTR (gst_base_transform_default_transform_meta);
355
356   klass->sink_event = GST_DEBUG_FUNCPTR (gst_base_transform_sink_eventfunc);
357   klass->src_event = GST_DEBUG_FUNCPTR (gst_base_transform_src_eventfunc);
358   klass->prepare_output_buffer =
359       GST_DEBUG_FUNCPTR (default_prepare_output_buffer);
360   klass->copy_metadata = GST_DEBUG_FUNCPTR (default_copy_metadata);
361   klass->submit_input_buffer = GST_DEBUG_FUNCPTR (default_submit_input_buffer);
362   klass->generate_output = GST_DEBUG_FUNCPTR (default_generate_output);
363 }
364
365 static void
366 gst_base_transform_init (GstBaseTransform * trans,
367     GstBaseTransformClass * bclass)
368 {
369   GstPadTemplate *pad_template;
370   GstBaseTransformPrivate *priv;
371
372   GST_DEBUG ("gst_base_transform_init");
373
374   priv = trans->priv = GST_BASE_TRANSFORM_GET_PRIVATE (trans);
375
376   pad_template =
377       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "sink");
378   g_return_if_fail (pad_template != NULL);
379   trans->sinkpad = gst_pad_new_from_template (pad_template, "sink");
380   gst_pad_set_event_function (trans->sinkpad,
381       GST_DEBUG_FUNCPTR (gst_base_transform_sink_event));
382   gst_pad_set_chain_function (trans->sinkpad,
383       GST_DEBUG_FUNCPTR (gst_base_transform_chain));
384   gst_pad_set_activatemode_function (trans->sinkpad,
385       GST_DEBUG_FUNCPTR (gst_base_transform_sink_activate_mode));
386   gst_pad_set_query_function (trans->sinkpad,
387       GST_DEBUG_FUNCPTR (gst_base_transform_query));
388   gst_element_add_pad (GST_ELEMENT (trans), trans->sinkpad);
389
390   pad_template =
391       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "src");
392   g_return_if_fail (pad_template != NULL);
393   trans->srcpad = gst_pad_new_from_template (pad_template, "src");
394   gst_pad_set_event_function (trans->srcpad,
395       GST_DEBUG_FUNCPTR (gst_base_transform_src_event));
396   gst_pad_set_getrange_function (trans->srcpad,
397       GST_DEBUG_FUNCPTR (gst_base_transform_getrange));
398   gst_pad_set_activatemode_function (trans->srcpad,
399       GST_DEBUG_FUNCPTR (gst_base_transform_src_activate_mode));
400   gst_pad_set_query_function (trans->srcpad,
401       GST_DEBUG_FUNCPTR (gst_base_transform_query));
402   gst_element_add_pad (GST_ELEMENT (trans), trans->srcpad);
403
404   priv->qos_enabled = DEFAULT_PROP_QOS;
405   priv->cache_caps1 = NULL;
406   priv->cache_caps2 = NULL;
407   priv->pad_mode = GST_PAD_MODE_NONE;
408   priv->gap_aware = FALSE;
409   priv->prefer_passthrough = TRUE;
410
411   priv->passthrough = FALSE;
412   if (bclass->transform == NULL) {
413     /* If no transform function, always_in_place is TRUE */
414     GST_DEBUG_OBJECT (trans, "setting in_place TRUE");
415     priv->always_in_place = TRUE;
416
417     if (bclass->transform_ip == NULL) {
418       GST_DEBUG_OBJECT (trans, "setting passthrough TRUE");
419       priv->passthrough = TRUE;
420     }
421   }
422
423   priv->processed = 0;
424   priv->dropped = 0;
425 }
426
427 static GstCaps *
428 gst_base_transform_default_transform_caps (GstBaseTransform * trans,
429     GstPadDirection direction, GstCaps * caps, GstCaps * filter)
430 {
431   GstCaps *ret;
432
433   GST_DEBUG_OBJECT (trans, "identity from: %" GST_PTR_FORMAT, caps);
434   /* no transform function, use the identity transform */
435   if (filter) {
436     ret = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
437   } else {
438     ret = gst_caps_ref (caps);
439   }
440   return ret;
441 }
442
443 /* given @caps on the src or sink pad (given by @direction)
444  * calculate the possible caps on the other pad.
445  *
446  * Returns new caps, unref after usage.
447  */
448 static GstCaps *
449 gst_base_transform_transform_caps (GstBaseTransform * trans,
450     GstPadDirection direction, GstCaps * caps, GstCaps * filter)
451 {
452   GstCaps *ret = NULL;
453   GstBaseTransformClass *klass;
454
455   if (caps == NULL)
456     return NULL;
457
458   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
459
460   /* if there is a custom transform function, use this */
461   if (klass->transform_caps) {
462     GST_DEBUG_OBJECT (trans, "transform caps (direction = %d)", direction);
463
464     GST_LOG_OBJECT (trans, "from: %" GST_PTR_FORMAT, caps);
465     ret = klass->transform_caps (trans, direction, caps, filter);
466     GST_LOG_OBJECT (trans, "  to: %" GST_PTR_FORMAT, ret);
467
468 #ifdef GST_ENABLE_EXTRA_CHECKS
469     if (filter) {
470       if (!gst_caps_is_subset (ret, filter)) {
471         GstCaps *intersection;
472
473         GST_ERROR_OBJECT (trans,
474             "transform_caps returned caps %" GST_PTR_FORMAT
475             " which are not a real subset of the filter caps %"
476             GST_PTR_FORMAT, ret, filter);
477         g_warning ("%s: transform_caps returned caps which are not a real "
478             "subset of the filter caps", GST_ELEMENT_NAME (trans));
479
480         intersection =
481             gst_caps_intersect_full (filter, ret, GST_CAPS_INTERSECT_FIRST);
482         gst_caps_unref (ret);
483         ret = intersection;
484       }
485     }
486 #endif
487   }
488
489   GST_DEBUG_OBJECT (trans, "to: %" GST_PTR_FORMAT, ret);
490
491   return ret;
492 }
493
494 static gboolean
495 gst_base_transform_default_transform_meta (GstBaseTransform * trans,
496     GstBuffer * inbuf, GstMeta * meta, GstBuffer * outbuf)
497 {
498   const GstMetaInfo *info = meta->info;
499   const gchar *const *tags;
500
501   tags = gst_meta_api_type_get_tags (info->api);
502
503   if (!tags)
504     return TRUE;
505
506   return FALSE;
507 }
508
509 static gboolean
510 gst_base_transform_default_transform_size (GstBaseTransform * trans,
511     GstPadDirection direction, GstCaps * caps, gsize size,
512     GstCaps * othercaps, gsize * othersize)
513 {
514   gsize inunitsize, outunitsize, units;
515   GstBaseTransformClass *klass;
516
517   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
518
519   if (klass->get_unit_size == NULL) {
520     /* if there is no transform_size and no unit_size, it means the
521      * element does not modify the size of a buffer */
522     *othersize = size;
523   } else {
524     /* there is no transform_size function, we have to use the unit_size
525      * functions. This method assumes there is a fixed unit_size associated with
526      * each caps. We provide the same amount of units on both sides. */
527     if (!gst_base_transform_get_unit_size (trans, caps, &inunitsize))
528       goto no_in_size;
529
530     GST_DEBUG_OBJECT (trans,
531         "input size %" G_GSIZE_FORMAT ", input unit size %" G_GSIZE_FORMAT,
532         size, inunitsize);
533
534     /* input size must be a multiple of the unit_size of the input caps */
535     if (inunitsize == 0 || (size % inunitsize != 0))
536       goto no_multiple;
537
538     /* get the amount of units */
539     units = size / inunitsize;
540
541     /* now get the unit size of the output */
542     if (!gst_base_transform_get_unit_size (trans, othercaps, &outunitsize))
543       goto no_out_size;
544
545     /* the output size is the unit_size times the amount of units on the
546      * input */
547     *othersize = units * outunitsize;
548     GST_DEBUG_OBJECT (trans, "transformed size to %" G_GSIZE_FORMAT,
549         *othersize);
550   }
551   return TRUE;
552
553   /* ERRORS */
554 no_in_size:
555   {
556     GST_DEBUG_OBJECT (trans, "could not get in_size");
557     g_warning ("%s: could not get in_size", GST_ELEMENT_NAME (trans));
558     return FALSE;
559   }
560 no_multiple:
561   {
562     GST_DEBUG_OBJECT (trans, "Size %" G_GSIZE_FORMAT " is not a multiple of"
563         "unit size %" G_GSIZE_FORMAT, size, inunitsize);
564     g_warning ("%s: size %" G_GSIZE_FORMAT " is not a multiple of unit size %"
565         G_GSIZE_FORMAT, GST_ELEMENT_NAME (trans), size, inunitsize);
566     return FALSE;
567   }
568 no_out_size:
569   {
570     GST_DEBUG_OBJECT (trans, "could not get out_size");
571     g_warning ("%s: could not get out_size", GST_ELEMENT_NAME (trans));
572     return FALSE;
573   }
574 }
575
576 /* transform a buffer of @size with @caps on the pad with @direction to
577  * the size of a buffer with @othercaps and store the result in @othersize
578  *
579  * We have two ways of doing this:
580  *  1) use a custom transform size function, this is for complicated custom
581  *     cases with no fixed unit_size.
582  *  2) use the unit_size functions where there is a relationship between the
583  *     caps and the size of a buffer.
584  */
585 static gboolean
586 gst_base_transform_transform_size (GstBaseTransform * trans,
587     GstPadDirection direction, GstCaps * caps,
588     gsize size, GstCaps * othercaps, gsize * othersize)
589 {
590   GstBaseTransformClass *klass;
591   gboolean ret = FALSE;
592
593   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
594
595   GST_DEBUG_OBJECT (trans,
596       "asked to transform size %" G_GSIZE_FORMAT " for caps %"
597       GST_PTR_FORMAT " to size for caps %" GST_PTR_FORMAT " in direction %s",
598       size, caps, othercaps, direction == GST_PAD_SRC ? "SRC" : "SINK");
599
600   if (klass->transform_size) {
601     /* if there is a custom transform function, use this */
602     ret = klass->transform_size (trans, direction, caps, size, othercaps,
603         othersize);
604   }
605   return ret;
606 }
607
608 /* get the caps that can be handled by @pad. We perform:
609  *
610  *  - take the caps of peer of otherpad,
611  *  - filter against the padtemplate of otherpad,
612  *  - calculate all transforms of remaining caps
613  *  - filter against template of @pad
614  *
615  * If there is no peer, we simply return the caps of the padtemplate of pad.
616  */
617 static GstCaps *
618 gst_base_transform_query_caps (GstBaseTransform * trans, GstPad * pad,
619     GstCaps * filter)
620 {
621   GstPad *otherpad;
622   GstCaps *peercaps = NULL, *caps, *temp, *peerfilter = NULL;
623   GstCaps *templ, *otempl;
624
625   otherpad = (pad == trans->srcpad) ? trans->sinkpad : trans->srcpad;
626
627   templ = gst_pad_get_pad_template_caps (pad);
628   otempl = gst_pad_get_pad_template_caps (otherpad);
629
630   /* first prepare the filter to be send onwards. We need to filter and
631    * transform it to valid caps for the otherpad. */
632   if (filter) {
633     GST_DEBUG_OBJECT (pad, "filter caps  %" GST_PTR_FORMAT, filter);
634
635     /* filtered against our padtemplate of this pad */
636     GST_DEBUG_OBJECT (pad, "our template  %" GST_PTR_FORMAT, templ);
637     temp = gst_caps_intersect_full (filter, templ, GST_CAPS_INTERSECT_FIRST);
638     GST_DEBUG_OBJECT (pad, "intersected %" GST_PTR_FORMAT, temp);
639
640     /* then see what we can transform this to */
641     peerfilter = gst_base_transform_transform_caps (trans,
642         GST_PAD_DIRECTION (pad), temp, NULL);
643     GST_DEBUG_OBJECT (pad, "transformed  %" GST_PTR_FORMAT, peerfilter);
644     gst_caps_unref (temp);
645
646     if (!gst_caps_is_empty (peerfilter)) {
647       /* and filter against the template of the other pad */
648       GST_DEBUG_OBJECT (pad, "our template  %" GST_PTR_FORMAT, otempl);
649       /* We keep the caps sorted like the returned caps */
650       temp =
651           gst_caps_intersect_full (peerfilter, otempl,
652           GST_CAPS_INTERSECT_FIRST);
653       GST_DEBUG_OBJECT (pad, "intersected %" GST_PTR_FORMAT, temp);
654       gst_caps_unref (peerfilter);
655       peerfilter = temp;
656     }
657   }
658
659   GST_DEBUG_OBJECT (pad, "peer filter caps %" GST_PTR_FORMAT, peerfilter);
660
661   if (peerfilter && gst_caps_is_empty (peerfilter)) {
662     GST_DEBUG_OBJECT (pad, "peer filter caps are empty");
663     caps = peerfilter;
664     peerfilter = NULL;
665     goto done;
666   }
667
668   /* query the peer with the transformed filter */
669   peercaps = gst_pad_peer_query_caps (otherpad, peerfilter);
670
671   if (peerfilter)
672     gst_caps_unref (peerfilter);
673
674   if (peercaps) {
675     GST_DEBUG_OBJECT (pad, "peer caps  %" GST_PTR_FORMAT, peercaps);
676
677     /* filtered against our padtemplate on the other side */
678     GST_DEBUG_OBJECT (pad, "our template  %" GST_PTR_FORMAT, otempl);
679     temp = gst_caps_intersect_full (peercaps, otempl, GST_CAPS_INTERSECT_FIRST);
680     GST_DEBUG_OBJECT (pad, "intersected %" GST_PTR_FORMAT, temp);
681   } else {
682     temp = gst_caps_ref (otempl);
683   }
684
685   /* then see what we can transform this to */
686   caps = gst_base_transform_transform_caps (trans,
687       GST_PAD_DIRECTION (otherpad), temp, filter);
688   GST_DEBUG_OBJECT (pad, "transformed  %" GST_PTR_FORMAT, caps);
689   gst_caps_unref (temp);
690   if (caps == NULL || gst_caps_is_empty (caps))
691     goto done;
692
693   if (peercaps) {
694     /* and filter against the template of this pad */
695     GST_DEBUG_OBJECT (pad, "our template  %" GST_PTR_FORMAT, templ);
696     /* We keep the caps sorted like the returned caps */
697     temp = gst_caps_intersect_full (caps, templ, GST_CAPS_INTERSECT_FIRST);
698     GST_DEBUG_OBJECT (pad, "intersected %" GST_PTR_FORMAT, temp);
699     gst_caps_unref (caps);
700     caps = temp;
701
702     if (trans->priv->prefer_passthrough) {
703       /* Now try if we can put the untransformed downstream caps first */
704       temp = gst_caps_intersect_full (peercaps, caps, GST_CAPS_INTERSECT_FIRST);
705       if (!gst_caps_is_empty (temp)) {
706         caps = gst_caps_merge (temp, caps);
707       } else {
708         gst_caps_unref (temp);
709       }
710     }
711   } else {
712     gst_caps_unref (caps);
713     /* no peer or the peer can do anything, our padtemplate is enough then */
714     if (filter) {
715       caps = gst_caps_intersect_full (filter, templ, GST_CAPS_INTERSECT_FIRST);
716     } else {
717       caps = gst_caps_ref (templ);
718     }
719   }
720
721 done:
722   GST_DEBUG_OBJECT (trans, "returning  %" GST_PTR_FORMAT, caps);
723
724   if (peercaps)
725     gst_caps_unref (peercaps);
726
727   gst_caps_unref (templ);
728   gst_caps_unref (otempl);
729
730   return caps;
731 }
732
733 /* takes ownership of the pool, allocator and query */
734 static gboolean
735 gst_base_transform_set_allocation (GstBaseTransform * trans,
736     GstBufferPool * pool, GstAllocator * allocator,
737     GstAllocationParams * params, GstQuery * query)
738 {
739   GstAllocator *oldalloc;
740   GstBufferPool *oldpool;
741   GstQuery *oldquery;
742   GstBaseTransformPrivate *priv = trans->priv;
743
744   GST_OBJECT_LOCK (trans);
745   oldpool = priv->pool;
746   priv->pool = pool;
747   priv->pool_active = FALSE;
748
749   oldalloc = priv->allocator;
750   priv->allocator = allocator;
751
752   oldquery = priv->query;
753   priv->query = query;
754
755   if (params)
756     priv->params = *params;
757   else
758     gst_allocation_params_init (&priv->params);
759   GST_OBJECT_UNLOCK (trans);
760
761   if (oldpool) {
762     GST_DEBUG_OBJECT (trans, "deactivating old pool %p", oldpool);
763     gst_buffer_pool_set_active (oldpool, FALSE);
764     gst_object_unref (oldpool);
765   }
766   if (oldalloc) {
767     gst_object_unref (oldalloc);
768   }
769   if (oldquery) {
770     gst_query_unref (oldquery);
771   }
772   return TRUE;
773 }
774
775 static gboolean
776 gst_base_transform_default_decide_allocation (GstBaseTransform * trans,
777     GstQuery * query)
778 {
779   guint i, n_metas;
780   GstBaseTransformClass *klass;
781   GstCaps *outcaps;
782   GstBufferPool *pool;
783   guint size, min, max;
784   GstAllocator *allocator;
785   GstAllocationParams params;
786   GstStructure *config;
787   gboolean update_allocator;
788
789   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
790
791   n_metas = gst_query_get_n_allocation_metas (query);
792   for (i = 0; i < n_metas; i++) {
793     GType api;
794     const GstStructure *params;
795     gboolean remove;
796
797     api = gst_query_parse_nth_allocation_meta (query, i, &params);
798
799     /* by default we remove all metadata, subclasses should implement a
800      * filter_meta function */
801     if (gst_meta_api_type_has_tag (api, _gst_meta_tag_memory)) {
802       /* remove all memory dependent metadata because we are going to have to
803        * allocate different memory for input and output. */
804       GST_LOG_OBJECT (trans, "removing memory specific metadata %s",
805           g_type_name (api));
806       remove = TRUE;
807     } else if (G_LIKELY (klass->filter_meta)) {
808       /* remove if the subclass said so */
809       remove = !klass->filter_meta (trans, query, api, params);
810       GST_LOG_OBJECT (trans, "filter_meta for api %s returned: %s",
811           g_type_name (api), (remove ? "remove" : "keep"));
812     } else {
813       GST_LOG_OBJECT (trans, "removing metadata %s", g_type_name (api));
814       remove = TRUE;
815     }
816
817     if (remove) {
818       gst_query_remove_nth_allocation_meta (query, i);
819       i--;
820       n_metas--;
821     }
822   }
823
824   gst_query_parse_allocation (query, &outcaps, NULL);
825
826   /* we got configuration from our peer or the decide_allocation method,
827    * parse them */
828   if (gst_query_get_n_allocation_params (query) > 0) {
829     /* try the allocator */
830     gst_query_parse_nth_allocation_param (query, 0, &allocator, &params);
831     update_allocator = TRUE;
832   } else {
833     allocator = NULL;
834     gst_allocation_params_init (&params);
835     update_allocator = FALSE;
836   }
837
838   if (gst_query_get_n_allocation_pools (query) > 0) {
839     gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
840
841     if (pool == NULL) {
842       /* no pool, we can make our own */
843       GST_DEBUG_OBJECT (trans, "no pool, making new pool");
844       pool = gst_buffer_pool_new ();
845     }
846   } else {
847     pool = NULL;
848     size = min = max = 0;
849   }
850
851   /* now configure */
852   if (pool) {
853     config = gst_buffer_pool_get_config (pool);
854     gst_buffer_pool_config_set_params (config, outcaps, size, min, max);
855     gst_buffer_pool_config_set_allocator (config, allocator, &params);
856
857     /* buffer pool may have to do some changes */
858     if (!gst_buffer_pool_set_config (pool, config)) {
859       config = gst_buffer_pool_get_config (pool);
860
861       /* If change are not acceptable, fallback to generic pool */
862       if (!gst_buffer_pool_config_validate_params (config, outcaps, size, min,
863               max)) {
864         GST_DEBUG_OBJECT (trans, "unsuported pool, making new pool");
865
866         gst_object_unref (pool);
867         pool = gst_buffer_pool_new ();
868         gst_buffer_pool_config_set_params (config, outcaps, size, min, max);
869         gst_buffer_pool_config_set_allocator (config, allocator, &params);
870       }
871
872       if (!gst_buffer_pool_set_config (pool, config))
873         goto config_failed;
874     }
875   }
876
877   if (update_allocator)
878     gst_query_set_nth_allocation_param (query, 0, allocator, &params);
879   else
880     gst_query_add_allocation_param (query, allocator, &params);
881   if (allocator)
882     gst_object_unref (allocator);
883
884   if (pool) {
885     gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
886     gst_object_unref (pool);
887   }
888
889   return TRUE;
890
891 config_failed:
892   if (pool)
893     gst_object_unref (pool);
894
895   GST_ELEMENT_ERROR (trans, RESOURCE, SETTINGS,
896       ("Failed to configure the buffer pool"),
897       ("Configuration is most likely invalid, please report this issue."));
898   return FALSE;
899 }
900
901 static gboolean
902 gst_base_transform_do_bufferpool (GstBaseTransform * trans, GstCaps * outcaps)
903 {
904   GstQuery *query;
905   gboolean result = TRUE;
906   GstBufferPool *pool = NULL;
907   GstBaseTransformClass *klass;
908   GstBaseTransformPrivate *priv = trans->priv;
909   GstAllocator *allocator;
910   GstAllocationParams params;
911
912   /* there are these possibilities:
913    *
914    * 1) we negotiated passthrough, we can proxy the bufferpool directly and we
915    *    will do that whenever some upstream does an allocation query.
916    * 2) we need to do a transform, we need to get a bufferpool from downstream
917    *    and configure it. When upstream does the ALLOCATION query, the
918    *    propose_allocation vmethod will be called and we will configure the
919    *    upstream allocator with our proposed values then.
920    */
921   if (priv->passthrough || priv->always_in_place) {
922     /* we are in passthrough, the input buffer is never copied and always passed
923      * along. We never allocate an output buffer on the srcpad. What we do is
924      * let the upstream element decide if it wants to use a bufferpool and
925      * then we will proxy the downstream pool */
926     GST_DEBUG_OBJECT (trans, "we're passthough, delay bufferpool");
927     gst_base_transform_set_allocation (trans, NULL, NULL, NULL, NULL);
928     return TRUE;
929   }
930
931   /* not passthrough, we need to allocate */
932   /* find a pool for the negotiated caps now */
933   GST_DEBUG_OBJECT (trans, "doing allocation query");
934   query = gst_query_new_allocation (outcaps, TRUE);
935   if (!gst_pad_peer_query (trans->srcpad, query)) {
936     /* not a problem, just debug a little */
937     GST_DEBUG_OBJECT (trans, "peer ALLOCATION query failed");
938   }
939
940   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
941
942   GST_DEBUG_OBJECT (trans, "calling decide_allocation");
943   g_assert (klass->decide_allocation != NULL);
944   result = klass->decide_allocation (trans, query);
945
946   GST_DEBUG_OBJECT (trans, "ALLOCATION (%d) params: %" GST_PTR_FORMAT, result,
947       query);
948
949   if (!result)
950     goto no_decide_allocation;
951
952   /* we got configuration from our peer or the decide_allocation method,
953    * parse them */
954   if (gst_query_get_n_allocation_params (query) > 0) {
955     gst_query_parse_nth_allocation_param (query, 0, &allocator, &params);
956   } else {
957     allocator = NULL;
958     gst_allocation_params_init (&params);
959   }
960
961   if (gst_query_get_n_allocation_pools (query) > 0)
962     gst_query_parse_nth_allocation_pool (query, 0, &pool, NULL, NULL, NULL);
963
964   /* now store */
965   result =
966       gst_base_transform_set_allocation (trans, pool, allocator, &params,
967       query);
968
969   return result;
970
971   /* Errors */
972 no_decide_allocation:
973   {
974     GST_WARNING_OBJECT (trans, "Subclass failed to decide allocation");
975     gst_query_unref (query);
976
977     return result;
978   }
979 }
980
981 /* function triggered when the in and out caps are negotiated and need
982  * to be configured in the subclass. */
983 static gboolean
984 gst_base_transform_configure_caps (GstBaseTransform * trans, GstCaps * in,
985     GstCaps * out)
986 {
987   gboolean ret = TRUE;
988   GstBaseTransformClass *klass;
989   GstBaseTransformPrivate *priv = trans->priv;
990
991   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
992
993   GST_DEBUG_OBJECT (trans, "in caps:  %" GST_PTR_FORMAT, in);
994   GST_DEBUG_OBJECT (trans, "out caps: %" GST_PTR_FORMAT, out);
995
996   /* clear the cache */
997   gst_caps_replace (&priv->cache_caps1, NULL);
998   gst_caps_replace (&priv->cache_caps2, NULL);
999
1000   /* figure out same caps state */
1001   priv->have_same_caps = gst_caps_is_equal (in, out);
1002   GST_DEBUG_OBJECT (trans, "have_same_caps: %d", priv->have_same_caps);
1003
1004   /* Set the passthrough if the class wants passthrough_on_same_caps
1005    * and we have the same caps on each pad */
1006   if (klass->passthrough_on_same_caps)
1007     gst_base_transform_set_passthrough (trans, priv->have_same_caps);
1008
1009   /* now configure the element with the caps */
1010   if (klass->set_caps) {
1011     GST_DEBUG_OBJECT (trans, "Calling set_caps method to setup caps");
1012     ret = klass->set_caps (trans, in, out);
1013   }
1014
1015   return ret;
1016 }
1017
1018 static GstCaps *
1019 gst_base_transform_default_fixate_caps (GstBaseTransform * trans,
1020     GstPadDirection direction, GstCaps * caps, GstCaps * othercaps)
1021 {
1022   othercaps = gst_caps_fixate (othercaps);
1023   GST_DEBUG_OBJECT (trans, "fixated to %" GST_PTR_FORMAT, othercaps);
1024
1025   return othercaps;
1026 }
1027
1028 /* given a fixed @caps on @pad, create the best possible caps for the
1029  * other pad.
1030  * @caps must be fixed when calling this function.
1031  *
1032  * This function calls the transform caps vmethod of the basetransform to figure
1033  * out the possible target formats. It then tries to select the best format from
1034  * this list by:
1035  *
1036  * - attempt passthrough if the target caps is a superset of the input caps
1037  * - fixating by using peer caps
1038  * - fixating with transform fixate function
1039  * - fixating with pad fixate functions.
1040  *
1041  * this function returns a caps that can be transformed into and is accepted by
1042  * the peer element.
1043  */
1044 static GstCaps *
1045 gst_base_transform_find_transform (GstBaseTransform * trans, GstPad * pad,
1046     GstCaps * caps)
1047 {
1048   GstBaseTransformClass *klass;
1049   GstPad *otherpad, *otherpeer;
1050   GstCaps *othercaps;
1051   gboolean is_fixed;
1052
1053   /* caps must be fixed here, this is a programming error if it's not */
1054   g_return_val_if_fail (gst_caps_is_fixed (caps), NULL);
1055
1056   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1057
1058   otherpad = (pad == trans->srcpad) ? trans->sinkpad : trans->srcpad;
1059   otherpeer = gst_pad_get_peer (otherpad);
1060
1061   /* see how we can transform the input caps. We need to do this even for
1062    * passthrough because it might be possible that this element cannot support
1063    * passthrough at all. */
1064   othercaps = gst_base_transform_transform_caps (trans,
1065       GST_PAD_DIRECTION (pad), caps, NULL);
1066
1067   /* The caps we can actually output is the intersection of the transformed
1068    * caps with the pad template for the pad */
1069   if (othercaps && !gst_caps_is_empty (othercaps)) {
1070     GstCaps *intersect, *templ_caps;
1071
1072     templ_caps = gst_pad_get_pad_template_caps (otherpad);
1073     GST_DEBUG_OBJECT (trans,
1074         "intersecting against padtemplate %" GST_PTR_FORMAT, templ_caps);
1075
1076     intersect =
1077         gst_caps_intersect_full (othercaps, templ_caps,
1078         GST_CAPS_INTERSECT_FIRST);
1079
1080     gst_caps_unref (othercaps);
1081     gst_caps_unref (templ_caps);
1082     othercaps = intersect;
1083   }
1084
1085   /* check if transform is empty */
1086   if (!othercaps || gst_caps_is_empty (othercaps))
1087     goto no_transform;
1088
1089   /* if the othercaps are not fixed, we need to fixate them, first attempt
1090    * is by attempting passthrough if the othercaps are a superset of caps. */
1091   /* FIXME. maybe the caps is not fixed because it has multiple structures of
1092    * fixed caps */
1093   is_fixed = gst_caps_is_fixed (othercaps);
1094   if (!is_fixed) {
1095     GST_DEBUG_OBJECT (trans,
1096         "transform returned non fixed  %" GST_PTR_FORMAT, othercaps);
1097
1098     /* Now let's see what the peer suggests based on our transformed caps */
1099     if (otherpeer) {
1100       GstCaps *peercaps, *intersection, *templ_caps;
1101
1102       GST_DEBUG_OBJECT (trans,
1103           "Checking peer caps with filter %" GST_PTR_FORMAT, othercaps);
1104
1105       peercaps = gst_pad_query_caps (otherpeer, othercaps);
1106       GST_DEBUG_OBJECT (trans, "Resulted in %" GST_PTR_FORMAT, peercaps);
1107       if (!gst_caps_is_empty (peercaps)) {
1108         templ_caps = gst_pad_get_pad_template_caps (otherpad);
1109
1110         GST_DEBUG_OBJECT (trans,
1111             "Intersecting with template caps %" GST_PTR_FORMAT, templ_caps);
1112
1113         intersection =
1114             gst_caps_intersect_full (peercaps, templ_caps,
1115             GST_CAPS_INTERSECT_FIRST);
1116         GST_DEBUG_OBJECT (trans, "Intersection: %" GST_PTR_FORMAT,
1117             intersection);
1118         gst_caps_unref (peercaps);
1119         gst_caps_unref (templ_caps);
1120         peercaps = intersection;
1121
1122         GST_DEBUG_OBJECT (trans,
1123             "Intersecting with transformed caps %" GST_PTR_FORMAT, othercaps);
1124         intersection =
1125             gst_caps_intersect_full (peercaps, othercaps,
1126             GST_CAPS_INTERSECT_FIRST);
1127         GST_DEBUG_OBJECT (trans, "Intersection: %" GST_PTR_FORMAT,
1128             intersection);
1129         gst_caps_unref (peercaps);
1130         gst_caps_unref (othercaps);
1131         othercaps = intersection;
1132       } else {
1133         gst_caps_unref (othercaps);
1134         othercaps = peercaps;
1135       }
1136
1137       is_fixed = gst_caps_is_fixed (othercaps);
1138     } else {
1139       GST_DEBUG_OBJECT (trans, "no peer, doing passthrough");
1140       gst_caps_unref (othercaps);
1141       othercaps = gst_caps_ref (caps);
1142       is_fixed = TRUE;
1143     }
1144   }
1145   if (gst_caps_is_empty (othercaps))
1146     goto no_transform_possible;
1147
1148   GST_DEBUG ("have %sfixed caps %" GST_PTR_FORMAT, (is_fixed ? "" : "non-"),
1149       othercaps);
1150
1151   /* second attempt at fixation, call the fixate vmethod */
1152   /* caps could be fixed but the subclass may want to add fields */
1153   if (klass->fixate_caps) {
1154     GST_DEBUG_OBJECT (trans, "calling fixate_caps for %" GST_PTR_FORMAT
1155         " using caps %" GST_PTR_FORMAT " on pad %s:%s", othercaps, caps,
1156         GST_DEBUG_PAD_NAME (otherpad));
1157     /* note that we pass the complete array of structures to the fixate
1158      * function, it needs to truncate itself */
1159     othercaps =
1160         klass->fixate_caps (trans, GST_PAD_DIRECTION (pad), caps, othercaps);
1161     is_fixed = gst_caps_is_fixed (othercaps);
1162     GST_DEBUG_OBJECT (trans, "after fixating %" GST_PTR_FORMAT, othercaps);
1163   }
1164
1165   /* caps should be fixed now, if not we have to fail. */
1166   if (!is_fixed)
1167     goto could_not_fixate;
1168
1169   /* and peer should accept */
1170   if (otherpeer && !gst_pad_query_accept_caps (otherpeer, othercaps))
1171     goto peer_no_accept;
1172
1173   GST_DEBUG_OBJECT (trans, "Input caps were %" GST_PTR_FORMAT
1174       ", and got final caps %" GST_PTR_FORMAT, caps, othercaps);
1175
1176   if (otherpeer)
1177     gst_object_unref (otherpeer);
1178
1179   return othercaps;
1180
1181   /* ERRORS */
1182 no_transform:
1183   {
1184     GST_DEBUG_OBJECT (trans,
1185         "transform returned useless  %" GST_PTR_FORMAT, othercaps);
1186     goto error_cleanup;
1187   }
1188 no_transform_possible:
1189   {
1190     GST_DEBUG_OBJECT (trans,
1191         "transform could not transform %" GST_PTR_FORMAT
1192         " in anything we support", caps);
1193     goto error_cleanup;
1194   }
1195 could_not_fixate:
1196   {
1197     GST_DEBUG_OBJECT (trans, "FAILED to fixate %" GST_PTR_FORMAT, othercaps);
1198     goto error_cleanup;
1199   }
1200 peer_no_accept:
1201   {
1202     GST_DEBUG_OBJECT (trans, "FAILED to get peer of %" GST_PTR_FORMAT
1203         " to accept %" GST_PTR_FORMAT, otherpad, othercaps);
1204     goto error_cleanup;
1205   }
1206 error_cleanup:
1207   {
1208     if (otherpeer)
1209       gst_object_unref (otherpeer);
1210     if (othercaps)
1211       gst_caps_unref (othercaps);
1212     return NULL;
1213   }
1214 }
1215
1216 static gboolean
1217 gst_base_transform_acceptcaps_default (GstBaseTransform * trans,
1218     GstPadDirection direction, GstCaps * caps)
1219 {
1220   GstPad *pad, *otherpad;
1221   GstCaps *templ, *otempl, *ocaps = NULL;
1222   gboolean ret = TRUE;
1223
1224   pad =
1225       (direction ==
1226       GST_PAD_SINK) ? GST_BASE_TRANSFORM_SINK_PAD (trans) :
1227       GST_BASE_TRANSFORM_SRC_PAD (trans);
1228   otherpad =
1229       (direction ==
1230       GST_PAD_SINK) ? GST_BASE_TRANSFORM_SRC_PAD (trans) :
1231       GST_BASE_TRANSFORM_SINK_PAD (trans);
1232
1233   GST_DEBUG_OBJECT (trans, "accept caps %" GST_PTR_FORMAT, caps);
1234
1235   templ = gst_pad_get_pad_template_caps (pad);
1236   otempl = gst_pad_get_pad_template_caps (otherpad);
1237
1238   /* get all the formats we can handle on this pad */
1239   GST_DEBUG_OBJECT (trans, "intersect with pad template: %" GST_PTR_FORMAT,
1240       templ);
1241   if (!gst_caps_can_intersect (caps, templ))
1242     goto reject_caps;
1243
1244   GST_DEBUG_OBJECT (trans, "trying to transform with filter: %"
1245       GST_PTR_FORMAT " (the other pad template)", otempl);
1246   ocaps = gst_base_transform_transform_caps (trans, direction, caps, otempl);
1247   if (!ocaps || gst_caps_is_empty (ocaps))
1248     goto no_transform_possible;
1249
1250 done:
1251   GST_DEBUG_OBJECT (trans, "accept-caps result: %d", ret);
1252   if (ocaps)
1253     gst_caps_unref (ocaps);
1254   gst_caps_unref (templ);
1255   gst_caps_unref (otempl);
1256   return ret;
1257
1258   /* ERRORS */
1259 reject_caps:
1260   {
1261     GST_DEBUG_OBJECT (trans, "caps can't intersect with the template");
1262     ret = FALSE;
1263     goto done;
1264   }
1265 no_transform_possible:
1266   {
1267     GST_DEBUG_OBJECT (trans,
1268         "transform could not transform %" GST_PTR_FORMAT
1269         " in anything we support", caps);
1270     ret = FALSE;
1271     goto done;
1272   }
1273 }
1274
1275 /* called when new caps arrive on the sink pad,
1276  * We try to find the best caps for the other side using our _find_transform()
1277  * function. If there are caps, we configure the transform for this new
1278  * transformation.
1279  */
1280 static gboolean
1281 gst_base_transform_setcaps (GstBaseTransform * trans, GstPad * pad,
1282     GstCaps * incaps)
1283 {
1284   GstBaseTransformPrivate *priv = trans->priv;
1285   GstCaps *outcaps, *prev_incaps = NULL, *prev_outcaps = NULL;
1286   gboolean ret = TRUE;
1287
1288   GST_DEBUG_OBJECT (pad, "have new caps %p %" GST_PTR_FORMAT, incaps, incaps);
1289
1290   /* find best possible caps for the other pad */
1291   outcaps = gst_base_transform_find_transform (trans, pad, incaps);
1292   if (!outcaps || gst_caps_is_empty (outcaps))
1293     goto no_transform_possible;
1294
1295   /* configure the element now */
1296
1297   /* if we have the same caps, we can optimize and reuse the input caps */
1298   if (gst_caps_is_equal (incaps, outcaps)) {
1299     GST_INFO_OBJECT (trans, "reuse caps");
1300     gst_caps_unref (outcaps);
1301     outcaps = gst_caps_ref (incaps);
1302   }
1303
1304   prev_incaps = gst_pad_get_current_caps (trans->sinkpad);
1305   prev_outcaps = gst_pad_get_current_caps (trans->srcpad);
1306   if (prev_incaps && prev_outcaps && gst_caps_is_equal (prev_incaps, incaps)
1307       && gst_caps_is_equal (prev_outcaps, outcaps)) {
1308     GST_DEBUG_OBJECT (trans,
1309         "New caps equal to old ones: %" GST_PTR_FORMAT " -> %" GST_PTR_FORMAT,
1310         incaps, outcaps);
1311     ret = TRUE;
1312   } else {
1313     /* call configure now */
1314     if (!(ret = gst_base_transform_configure_caps (trans, incaps, outcaps)))
1315       goto failed_configure;
1316
1317     if (!prev_outcaps || !gst_caps_is_equal (outcaps, prev_outcaps))
1318       /* let downstream know about our caps */
1319       ret = gst_pad_set_caps (trans->srcpad, outcaps);
1320   }
1321
1322   if (ret) {
1323     /* try to get a pool when needed */
1324     ret = gst_base_transform_do_bufferpool (trans, outcaps);
1325   }
1326
1327 done:
1328   if (outcaps)
1329     gst_caps_unref (outcaps);
1330   if (prev_incaps)
1331     gst_caps_unref (prev_incaps);
1332   if (prev_outcaps)
1333     gst_caps_unref (prev_outcaps);
1334
1335   GST_OBJECT_LOCK (trans);
1336   priv->negotiated = ret;
1337   GST_OBJECT_UNLOCK (trans);
1338
1339   return ret;
1340
1341   /* ERRORS */
1342 no_transform_possible:
1343   {
1344     GST_WARNING_OBJECT (trans,
1345         "transform could not transform %" GST_PTR_FORMAT
1346         " in anything we support", incaps);
1347     ret = FALSE;
1348     goto done;
1349   }
1350 failed_configure:
1351   {
1352     GST_WARNING_OBJECT (trans, "FAILED to configure incaps %" GST_PTR_FORMAT
1353         " and outcaps %" GST_PTR_FORMAT, incaps, outcaps);
1354     ret = FALSE;
1355     goto done;
1356   }
1357 }
1358
1359 static gboolean
1360 gst_base_transform_default_propose_allocation (GstBaseTransform * trans,
1361     GstQuery * decide_query, GstQuery * query)
1362 {
1363   gboolean ret;
1364
1365   if (decide_query == NULL) {
1366     GST_DEBUG_OBJECT (trans, "doing passthrough query");
1367     ret = gst_pad_peer_query (trans->srcpad, query);
1368   } else {
1369     guint i, n_metas;
1370     /* non-passthrough, copy all metadata, decide_query does not contain the
1371      * metadata anymore that depends on the buffer memory */
1372     n_metas = gst_query_get_n_allocation_metas (decide_query);
1373     for (i = 0; i < n_metas; i++) {
1374       GType api;
1375       const GstStructure *params;
1376
1377       api = gst_query_parse_nth_allocation_meta (decide_query, i, &params);
1378       GST_DEBUG_OBJECT (trans, "proposing metadata %s", g_type_name (api));
1379       gst_query_add_allocation_meta (query, api, params);
1380     }
1381     ret = TRUE;
1382   }
1383   return ret;
1384 }
1385
1386 static gboolean
1387 gst_base_transform_reconfigure (GstBaseTransform * trans)
1388 {
1389   gboolean reconfigure, ret = TRUE;
1390
1391   reconfigure = gst_pad_check_reconfigure (trans->srcpad);
1392
1393   if (G_UNLIKELY (reconfigure)) {
1394     GstCaps *incaps;
1395
1396     GST_DEBUG_OBJECT (trans, "we had a pending reconfigure");
1397
1398     incaps = gst_pad_get_current_caps (trans->sinkpad);
1399     if (incaps == NULL)
1400       goto done;
1401
1402     /* if we need to reconfigure we pretend new caps arrived. This
1403      * will reconfigure the transform with the new output format. */
1404     if (!gst_base_transform_setcaps (trans, trans->sinkpad, incaps)) {
1405       GST_ELEMENT_WARNING (trans, STREAM, FORMAT,
1406           ("not negotiated"), ("not negotiated"));
1407       ret = FALSE;
1408     }
1409
1410     gst_caps_unref (incaps);
1411   }
1412
1413 done:
1414
1415   if (!ret)
1416     gst_pad_mark_reconfigure (trans->srcpad);
1417
1418   return ret;
1419 }
1420
1421 static gboolean
1422 gst_base_transform_default_query (GstBaseTransform * trans,
1423     GstPadDirection direction, GstQuery * query)
1424 {
1425   gboolean ret = FALSE;
1426   GstPad *pad, *otherpad;
1427   GstBaseTransformClass *klass;
1428   GstBaseTransformPrivate *priv = trans->priv;
1429
1430   if (direction == GST_PAD_SRC) {
1431     pad = trans->srcpad;
1432     otherpad = trans->sinkpad;
1433   } else {
1434     pad = trans->sinkpad;
1435     otherpad = trans->srcpad;
1436   }
1437
1438   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1439
1440   switch (GST_QUERY_TYPE (query)) {
1441     case GST_QUERY_ALLOCATION:
1442     {
1443       GstQuery *decide_query = NULL;
1444
1445       /* can only be done on the sinkpad */
1446       if (direction != GST_PAD_SINK)
1447         goto done;
1448
1449       ret = gst_base_transform_reconfigure (trans);
1450       if (G_UNLIKELY (!ret))
1451         goto done;
1452
1453       GST_OBJECT_LOCK (trans);
1454       if (!priv->negotiated && !priv->passthrough && (klass->set_caps != NULL)) {
1455         GST_DEBUG_OBJECT (trans,
1456             "not negotiated yet but need negotiation, can't answer ALLOCATION query");
1457         GST_OBJECT_UNLOCK (trans);
1458         goto done;
1459       }
1460
1461       decide_query = trans->priv->query;
1462       trans->priv->query = NULL;
1463       GST_OBJECT_UNLOCK (trans);
1464
1465       GST_DEBUG_OBJECT (trans,
1466           "calling propose allocation with query %" GST_PTR_FORMAT,
1467           decide_query);
1468
1469       /* pass the query to the propose_allocation vmethod if any */
1470       if (G_LIKELY (klass->propose_allocation))
1471         ret = klass->propose_allocation (trans, decide_query, query);
1472       else
1473         ret = FALSE;
1474
1475       if (decide_query) {
1476         GST_OBJECT_LOCK (trans);
1477
1478         if (trans->priv->query == NULL)
1479           trans->priv->query = decide_query;
1480         else
1481           gst_query_unref (decide_query);
1482
1483         GST_OBJECT_UNLOCK (trans);
1484       }
1485
1486       GST_DEBUG_OBJECT (trans, "ALLOCATION ret %d, %" GST_PTR_FORMAT, ret,
1487           query);
1488       break;
1489     }
1490     case GST_QUERY_POSITION:
1491     {
1492       GstFormat format;
1493
1494       gst_query_parse_position (query, &format, NULL);
1495       if (format == GST_FORMAT_TIME && trans->segment.format == GST_FORMAT_TIME) {
1496         gint64 pos;
1497         ret = TRUE;
1498
1499         if ((direction == GST_PAD_SINK)
1500             || (trans->priv->position_out == GST_CLOCK_TIME_NONE)) {
1501           pos =
1502               gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME,
1503               trans->segment.position);
1504         } else {
1505           pos = gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME,
1506               trans->priv->position_out);
1507         }
1508         gst_query_set_position (query, format, pos);
1509       } else {
1510         ret = gst_pad_peer_query (otherpad, query);
1511       }
1512       break;
1513     }
1514     case GST_QUERY_ACCEPT_CAPS:
1515     {
1516       GstCaps *caps;
1517
1518       gst_query_parse_accept_caps (query, &caps);
1519       if (klass->accept_caps) {
1520         ret = klass->accept_caps (trans, direction, caps);
1521         gst_query_set_accept_caps_result (query, ret);
1522         /* return TRUE, we answered the query */
1523         ret = TRUE;
1524       }
1525       break;
1526     }
1527     case GST_QUERY_CAPS:
1528     {
1529       GstCaps *filter, *caps;
1530
1531       gst_query_parse_caps (query, &filter);
1532       caps = gst_base_transform_query_caps (trans, pad, filter);
1533       gst_query_set_caps_result (query, caps);
1534       gst_caps_unref (caps);
1535       ret = TRUE;
1536       break;
1537     }
1538     default:
1539       ret = gst_pad_peer_query (otherpad, query);
1540       break;
1541   }
1542
1543 done:
1544   return ret;
1545 }
1546
1547 static gboolean
1548 gst_base_transform_query (GstPad * pad, GstObject * parent, GstQuery * query)
1549 {
1550   GstBaseTransform *trans;
1551   GstBaseTransformClass *bclass;
1552   gboolean ret = FALSE;
1553
1554   trans = GST_BASE_TRANSFORM (parent);
1555   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1556
1557   if (bclass->query)
1558     ret = bclass->query (trans, GST_PAD_DIRECTION (pad), query);
1559
1560   return ret;
1561 }
1562
1563 /* this function either returns the input buffer without incrementing the
1564  * refcount or it allocates a new (writable) buffer */
1565 static GstFlowReturn
1566 default_prepare_output_buffer (GstBaseTransform * trans,
1567     GstBuffer * inbuf, GstBuffer ** outbuf)
1568 {
1569   GstBaseTransformPrivate *priv;
1570   GstFlowReturn ret;
1571   GstBaseTransformClass *bclass;
1572   GstCaps *incaps, *outcaps;
1573   gsize insize, outsize;
1574   gboolean res;
1575
1576   priv = trans->priv;
1577   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1578
1579   /* figure out how to allocate an output buffer */
1580   if (priv->passthrough) {
1581     /* passthrough, we will not modify the incoming buffer so we can just
1582      * reuse it */
1583     GST_DEBUG_OBJECT (trans, "passthrough: reusing input buffer");
1584     *outbuf = inbuf;
1585     goto done;
1586   }
1587
1588   /* we can't reuse the input buffer */
1589   if (priv->pool) {
1590     if (!priv->pool_active) {
1591       GST_DEBUG_OBJECT (trans, "setting pool %p active", priv->pool);
1592       if (!gst_buffer_pool_set_active (priv->pool, TRUE))
1593         goto activate_failed;
1594       priv->pool_active = TRUE;
1595     }
1596     GST_DEBUG_OBJECT (trans, "using pool alloc");
1597     ret = gst_buffer_pool_acquire_buffer (priv->pool, outbuf, NULL);
1598     if (ret != GST_FLOW_OK)
1599       goto alloc_failed;
1600
1601     goto copy_meta;
1602   }
1603
1604   /* no pool, we need to figure out the size of the output buffer first */
1605   if ((bclass->transform_ip != NULL) && priv->always_in_place) {
1606     /* we want to do an in-place alloc */
1607     if (gst_buffer_is_writable (inbuf)) {
1608       GST_DEBUG_OBJECT (trans, "inplace reuse writable input buffer");
1609       *outbuf = inbuf;
1610     } else {
1611       GST_DEBUG_OBJECT (trans, "making writable buffer copy");
1612       /* we make a copy of the input buffer */
1613       *outbuf = gst_buffer_copy (inbuf);
1614     }
1615     goto done;
1616   }
1617
1618   /* else use the transform function to get the size */
1619   incaps = gst_pad_get_current_caps (trans->sinkpad);
1620   outcaps = gst_pad_get_current_caps (trans->srcpad);
1621
1622   /* srcpad might be flushing already if we're being shut down */
1623   if (outcaps == NULL)
1624     goto no_outcaps;
1625
1626   GST_DEBUG_OBJECT (trans, "getting output size for alloc");
1627   /* copy transform, figure out the output size */
1628   insize = gst_buffer_get_size (inbuf);
1629   res = gst_base_transform_transform_size (trans,
1630       GST_PAD_SINK, incaps, insize, outcaps, &outsize);
1631
1632   gst_caps_unref (incaps);
1633   gst_caps_unref (outcaps);
1634
1635   if (!res)
1636     goto unknown_size;
1637
1638   GST_DEBUG_OBJECT (trans, "doing alloc of size %" G_GSIZE_FORMAT, outsize);
1639   *outbuf = gst_buffer_new_allocate (priv->allocator, outsize, &priv->params);
1640   if (!*outbuf) {
1641     ret = GST_FLOW_ERROR;
1642     goto alloc_failed;
1643   }
1644
1645 copy_meta:
1646   /* copy the metadata */
1647   if (bclass->copy_metadata)
1648     if (!bclass->copy_metadata (trans, inbuf, *outbuf)) {
1649       /* something failed, post a warning */
1650       GST_ELEMENT_WARNING (trans, STREAM, NOT_IMPLEMENTED,
1651           ("could not copy metadata"), (NULL));
1652     }
1653
1654 done:
1655   return GST_FLOW_OK;
1656
1657   /* ERRORS */
1658 activate_failed:
1659   {
1660     GST_ELEMENT_ERROR (trans, RESOURCE, SETTINGS,
1661         ("failed to activate bufferpool"), ("failed to activate bufferpool"));
1662     return GST_FLOW_ERROR;
1663   }
1664 unknown_size:
1665   {
1666     GST_ERROR_OBJECT (trans, "unknown output size");
1667     return GST_FLOW_ERROR;
1668   }
1669 alloc_failed:
1670   {
1671     GST_DEBUG_OBJECT (trans, "could not allocate buffer from pool");
1672     return ret;
1673   }
1674 no_outcaps:
1675   {
1676     GST_DEBUG_OBJECT (trans, "no output caps, source pad has been deactivated");
1677     gst_caps_unref (incaps);
1678     return GST_FLOW_FLUSHING;
1679   }
1680 }
1681
1682 typedef struct
1683 {
1684   GstBaseTransform *trans;
1685   GstBuffer *outbuf;
1686 } CopyMetaData;
1687
1688 static gboolean
1689 foreach_metadata (GstBuffer * inbuf, GstMeta ** meta, gpointer user_data)
1690 {
1691   CopyMetaData *data = user_data;
1692   GstBaseTransform *trans = data->trans;
1693   GstBaseTransformClass *klass;
1694   const GstMetaInfo *info = (*meta)->info;
1695   GstBuffer *outbuf = data->outbuf;
1696   gboolean do_copy = FALSE;
1697
1698   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1699
1700   if (gst_meta_api_type_has_tag (info->api, _gst_meta_tag_memory)) {
1701     /* never call the transform_meta with memory specific metadata */
1702     GST_DEBUG_OBJECT (trans, "not copying memory specific metadata %s",
1703         g_type_name (info->api));
1704     do_copy = FALSE;
1705   } else if (klass->transform_meta) {
1706     do_copy = klass->transform_meta (trans, outbuf, *meta, inbuf);
1707     GST_DEBUG_OBJECT (trans, "transformed metadata %s: copy: %d",
1708         g_type_name (info->api), do_copy);
1709   }
1710
1711   /* we only copy metadata when the subclass implemented a transform_meta
1712    * function and when it returns %TRUE */
1713   if (do_copy) {
1714     GstMetaTransformCopy copy_data = { FALSE, 0, -1 };
1715     /* simply copy then */
1716     if (info->transform_func) {
1717         GST_DEBUG_OBJECT (trans, "copy metadata %s", g_type_name (info->api));
1718         info->transform_func (outbuf, *meta, inbuf,
1719             _gst_meta_transform_copy, &copy_data);
1720     } else {
1721         GST_DEBUG_OBJECT (trans, "couldn't copy metadata %s",
1722                           g_type_name (info->api));
1723     }
1724   }
1725   return TRUE;
1726 }
1727
1728 static gboolean
1729 default_copy_metadata (GstBaseTransform * trans,
1730     GstBuffer * inbuf, GstBuffer * outbuf)
1731 {
1732   GstBaseTransformPrivate *priv = trans->priv;
1733   CopyMetaData data;
1734
1735   /* now copy the metadata */
1736   GST_DEBUG_OBJECT (trans, "copying metadata");
1737
1738   /* this should not happen, buffers allocated from a pool or with
1739    * new_allocate should always be writable. */
1740   if (!gst_buffer_is_writable (outbuf))
1741     goto not_writable;
1742
1743   /* when we get here, the metadata should be writable */
1744   gst_buffer_copy_into (outbuf, inbuf,
1745       GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
1746
1747   /* clear the GAP flag when the subclass does not understand it */
1748   if (!priv->gap_aware)
1749     GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_GAP);
1750
1751
1752   data.trans = trans;
1753   data.outbuf = outbuf;
1754
1755   gst_buffer_foreach_meta (inbuf, foreach_metadata, &data);
1756
1757   return TRUE;
1758
1759   /* ERRORS */
1760 not_writable:
1761   {
1762     GST_WARNING_OBJECT (trans, "buffer %p not writable", outbuf);
1763     return FALSE;
1764   }
1765 }
1766
1767 /* Given @caps calcultate the size of one unit.
1768  *
1769  * For video caps, this is the size of one frame (and thus one buffer).
1770  * For audio caps, this is the size of one sample.
1771  *
1772  * These values are cached since they do not change and the calculation
1773  * potentially involves parsing caps and other expensive stuff.
1774  *
1775  * We have two cache locations to store the size, one for the source caps
1776  * and one for the sink caps.
1777  *
1778  * this function returns %FALSE if no size could be calculated.
1779  */
1780 static gboolean
1781 gst_base_transform_get_unit_size (GstBaseTransform * trans, GstCaps * caps,
1782     gsize * size)
1783 {
1784   gboolean res = FALSE;
1785   GstBaseTransformClass *bclass;
1786   GstBaseTransformPrivate *priv = trans->priv;
1787
1788   /* see if we have the result cached */
1789   if (priv->cache_caps1 == caps) {
1790     *size = priv->cache_caps1_size;
1791     GST_DEBUG_OBJECT (trans,
1792         "returned %" G_GSIZE_FORMAT " from first cache", *size);
1793     return TRUE;
1794   }
1795   if (priv->cache_caps2 == caps) {
1796     *size = priv->cache_caps2_size;
1797     GST_DEBUG_OBJECT (trans,
1798         "returned %" G_GSIZE_FORMAT " from second cached", *size);
1799     return TRUE;
1800   }
1801
1802   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1803   res = bclass->get_unit_size (trans, caps, size);
1804   GST_DEBUG_OBJECT (trans,
1805       "caps %" GST_PTR_FORMAT " has unit size %" G_GSIZE_FORMAT ", res %s",
1806       caps, *size, res ? "TRUE" : "FALSE");
1807
1808   if (res) {
1809     /* and cache the values */
1810     if (priv->cache_caps1 == NULL) {
1811       gst_caps_replace (&priv->cache_caps1, caps);
1812       priv->cache_caps1_size = *size;
1813       GST_DEBUG_OBJECT (trans,
1814           "caching %" G_GSIZE_FORMAT " in first cache", *size);
1815     } else if (priv->cache_caps2 == NULL) {
1816       gst_caps_replace (&priv->cache_caps2, caps);
1817       priv->cache_caps2_size = *size;
1818       GST_DEBUG_OBJECT (trans,
1819           "caching %" G_GSIZE_FORMAT " in second cache", *size);
1820     } else {
1821       GST_DEBUG_OBJECT (trans, "no free spot to cache unit_size");
1822     }
1823   }
1824   return res;
1825 }
1826
1827 static gboolean
1828 gst_base_transform_sink_event (GstPad * pad, GstObject * parent,
1829     GstEvent * event)
1830 {
1831   GstBaseTransform *trans;
1832   GstBaseTransformClass *bclass;
1833   gboolean ret = TRUE;
1834
1835   trans = GST_BASE_TRANSFORM (parent);
1836   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1837
1838   if (bclass->sink_event)
1839     ret = bclass->sink_event (trans, event);
1840   else
1841     gst_event_unref (event);
1842
1843   return ret;
1844 }
1845
1846 static gboolean
1847 gst_base_transform_sink_eventfunc (GstBaseTransform * trans, GstEvent * event)
1848 {
1849   gboolean ret = TRUE, forward = TRUE;
1850   GstBaseTransformPrivate *priv = trans->priv;
1851
1852   switch (GST_EVENT_TYPE (event)) {
1853     case GST_EVENT_FLUSH_START:
1854       break;
1855     case GST_EVENT_FLUSH_STOP:
1856       GST_OBJECT_LOCK (trans);
1857       /* reset QoS parameters */
1858       priv->proportion = 1.0;
1859       priv->earliest_time = -1;
1860       priv->discont = FALSE;
1861       priv->processed = 0;
1862       priv->dropped = 0;
1863       GST_OBJECT_UNLOCK (trans);
1864       /* we need new segment info after the flush. */
1865       trans->have_segment = FALSE;
1866       gst_segment_init (&trans->segment, GST_FORMAT_UNDEFINED);
1867       priv->position_out = GST_CLOCK_TIME_NONE;
1868       break;
1869     case GST_EVENT_EOS:
1870       break;
1871     case GST_EVENT_TAG:
1872       break;
1873     case GST_EVENT_CAPS:
1874     {
1875       GstCaps *caps;
1876
1877       gst_event_parse_caps (event, &caps);
1878       /* clear any pending reconfigure flag */
1879       gst_pad_check_reconfigure (trans->srcpad);
1880       ret = gst_base_transform_setcaps (trans, trans->sinkpad, caps);
1881       if (!ret)
1882         gst_pad_mark_reconfigure (trans->srcpad);
1883
1884       forward = FALSE;
1885       break;
1886     }
1887     case GST_EVENT_SEGMENT:
1888     {
1889       gst_event_copy_segment (event, &trans->segment);
1890       trans->have_segment = TRUE;
1891
1892       GST_DEBUG_OBJECT (trans, "received SEGMENT %" GST_SEGMENT_FORMAT,
1893           &trans->segment);
1894       break;
1895     }
1896     default:
1897       break;
1898   }
1899
1900   if (ret && forward)
1901     ret = gst_pad_push_event (trans->srcpad, event);
1902   else
1903     gst_event_unref (event);
1904
1905   return ret;
1906 }
1907
1908 static gboolean
1909 gst_base_transform_src_event (GstPad * pad, GstObject * parent,
1910     GstEvent * event)
1911 {
1912   GstBaseTransform *trans;
1913   GstBaseTransformClass *bclass;
1914   gboolean ret = TRUE;
1915
1916   trans = GST_BASE_TRANSFORM (parent);
1917   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1918
1919   if (bclass->src_event)
1920     ret = bclass->src_event (trans, event);
1921   else
1922     gst_event_unref (event);
1923
1924   return ret;
1925 }
1926
1927 static gboolean
1928 gst_base_transform_src_eventfunc (GstBaseTransform * trans, GstEvent * event)
1929 {
1930   gboolean ret;
1931
1932   GST_DEBUG_OBJECT (trans, "handling event %p %" GST_PTR_FORMAT, event, event);
1933
1934   switch (GST_EVENT_TYPE (event)) {
1935     case GST_EVENT_SEEK:
1936       break;
1937     case GST_EVENT_NAVIGATION:
1938       break;
1939     case GST_EVENT_QOS:
1940     {
1941       gdouble proportion;
1942       GstClockTimeDiff diff;
1943       GstClockTime timestamp;
1944
1945       gst_event_parse_qos (event, NULL, &proportion, &diff, &timestamp);
1946       gst_base_transform_update_qos (trans, proportion, diff, timestamp);
1947       break;
1948     }
1949     default:
1950       break;
1951   }
1952
1953   ret = gst_pad_push_event (trans->sinkpad, event);
1954
1955   return ret;
1956 }
1957
1958 /* Takes the input buffer */
1959 static GstFlowReturn
1960 default_submit_input_buffer (GstBaseTransform * trans, gboolean is_discont,
1961     GstBuffer * inbuf)
1962 {
1963   GstBaseTransformClass *bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1964   GstBaseTransformPrivate *priv = trans->priv;
1965   GstFlowReturn ret = GST_FLOW_OK;
1966   GstClockTime running_time;
1967   GstClockTime timestamp;
1968
1969   if (G_UNLIKELY (!gst_base_transform_reconfigure (trans)))
1970     goto not_negotiated;
1971
1972   if (GST_BUFFER_OFFSET_IS_VALID (inbuf))
1973     GST_DEBUG_OBJECT (trans,
1974         "handling buffer %p of size %" G_GSIZE_FORMAT ", PTS %" GST_TIME_FORMAT
1975         " and offset %" G_GUINT64_FORMAT, inbuf, gst_buffer_get_size (inbuf),
1976         GST_TIME_ARGS (GST_BUFFER_PTS (inbuf)), GST_BUFFER_OFFSET (inbuf));
1977   else
1978     GST_DEBUG_OBJECT (trans,
1979         "handling buffer %p of size %" G_GSIZE_FORMAT ", PTS %" GST_TIME_FORMAT
1980         " and offset NONE", inbuf, gst_buffer_get_size (inbuf),
1981         GST_TIME_ARGS (GST_BUFFER_PTS (inbuf)));
1982
1983   /* Don't allow buffer handling before negotiation, except in passthrough mode
1984    * or if the class doesn't implement a set_caps function (in which case it doesn't
1985    * care about caps)
1986    */
1987   if (!priv->negotiated && !priv->passthrough && (bclass->set_caps != NULL))
1988     goto not_negotiated;
1989
1990   /* can only do QoS if the segment is in TIME */
1991   if (trans->segment.format != GST_FORMAT_TIME)
1992     goto no_qos;
1993
1994   /* QOS is done on the running time of the buffer, get it now */
1995   timestamp = GST_BUFFER_TIMESTAMP (inbuf);
1996   running_time = gst_segment_to_running_time (&trans->segment, GST_FORMAT_TIME,
1997       timestamp);
1998
1999   if (running_time != -1) {
2000     gboolean need_skip;
2001     GstClockTime earliest_time;
2002     gdouble proportion;
2003
2004     /* lock for getting the QoS parameters that are set (in a different thread)
2005      * with the QOS events */
2006     GST_OBJECT_LOCK (trans);
2007     earliest_time = priv->earliest_time;
2008     proportion = priv->proportion;
2009     /* check for QoS, don't perform conversion for buffers
2010      * that are known to be late. */
2011     need_skip = priv->qos_enabled &&
2012         earliest_time != -1 && running_time <= earliest_time;
2013     GST_OBJECT_UNLOCK (trans);
2014
2015     if (need_skip) {
2016       GstMessage *qos_msg;
2017       GstClockTime duration;
2018       guint64 stream_time;
2019       gint64 jitter;
2020
2021       GST_CAT_DEBUG_OBJECT (GST_CAT_QOS, trans, "skipping transform: qostime %"
2022           GST_TIME_FORMAT " <= %" GST_TIME_FORMAT,
2023           GST_TIME_ARGS (running_time), GST_TIME_ARGS (earliest_time));
2024
2025       priv->dropped++;
2026
2027       duration = GST_BUFFER_DURATION (inbuf);
2028       stream_time =
2029           gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME,
2030           timestamp);
2031       jitter = GST_CLOCK_DIFF (running_time, earliest_time);
2032
2033       qos_msg =
2034           gst_message_new_qos (GST_OBJECT_CAST (trans), FALSE, running_time,
2035           stream_time, timestamp, duration);
2036       gst_message_set_qos_values (qos_msg, jitter, proportion, 1000000);
2037       gst_message_set_qos_stats (qos_msg, GST_FORMAT_BUFFERS,
2038           priv->processed, priv->dropped);
2039       gst_element_post_message (GST_ELEMENT_CAST (trans), qos_msg);
2040
2041       /* mark discont for next buffer */
2042       priv->discont = TRUE;
2043       ret = GST_BASE_TRANSFORM_FLOW_DROPPED;
2044       goto skip;
2045     }
2046   }
2047
2048 no_qos:
2049   /* Stash input buffer where the default generate_output
2050    * function can find it */
2051   if (trans->queued_buf)
2052     gst_buffer_unref (trans->queued_buf);
2053   trans->queued_buf = inbuf;
2054   return ret;
2055 skip:
2056   gst_buffer_unref (inbuf);
2057   return ret;
2058
2059 not_negotiated:
2060   {
2061     gst_buffer_unref (inbuf);
2062     if (GST_PAD_IS_FLUSHING (trans->srcpad))
2063       return GST_FLOW_FLUSHING;
2064     return GST_FLOW_NOT_NEGOTIATED;
2065   }
2066 }
2067
2068 static GstFlowReturn
2069 default_generate_output (GstBaseTransform * trans, GstBuffer ** outbuf)
2070 {
2071   GstBaseTransformClass *bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2072   GstBaseTransformPrivate *priv = trans->priv;
2073   GstFlowReturn ret = GST_FLOW_OK;
2074   GstBuffer *inbuf;
2075   gboolean want_in_place;
2076
2077   /* Retrieve stashed input buffer, if the default submit_input_buffer
2078    * was run. Takes ownership back from there */
2079   inbuf = trans->queued_buf;
2080   trans->queued_buf = NULL;
2081
2082   /* This default processing method needs one input buffer to feed to
2083    * the transform functions, we can't do anything without it */
2084   if (inbuf == NULL)
2085     return GST_FLOW_OK;
2086
2087   /* first try to allocate an output buffer based on the currently negotiated
2088    * format. outbuf will contain a buffer suitable for doing the configured
2089    * transform after this function. */
2090   if (bclass->prepare_output_buffer == NULL)
2091     goto no_prepare;
2092
2093   GST_DEBUG_OBJECT (trans, "calling prepare buffer");
2094   ret = bclass->prepare_output_buffer (trans, inbuf, outbuf);
2095
2096   if (ret != GST_FLOW_OK || *outbuf == NULL)
2097     goto no_buffer;
2098
2099   GST_DEBUG_OBJECT (trans, "using allocated buffer in %p, out %p", inbuf,
2100       *outbuf);
2101
2102   /* now perform the needed transform */
2103   if (priv->passthrough) {
2104     /* In passthrough mode, give transform_ip a look at the
2105      * buffer, without making it writable, or just push the
2106      * data through */
2107     if (bclass->transform_ip_on_passthrough && bclass->transform_ip) {
2108       GST_DEBUG_OBJECT (trans, "doing passthrough transform_ip");
2109       ret = bclass->transform_ip (trans, *outbuf);
2110     } else {
2111       GST_DEBUG_OBJECT (trans, "element is in passthrough");
2112     }
2113   } else {
2114     want_in_place = (bclass->transform_ip != NULL) && priv->always_in_place;
2115
2116     if (want_in_place) {
2117       GST_DEBUG_OBJECT (trans, "doing inplace transform");
2118       ret = bclass->transform_ip (trans, *outbuf);
2119     } else {
2120       GST_DEBUG_OBJECT (trans, "doing non-inplace transform");
2121
2122       if (bclass->transform)
2123         ret = bclass->transform (trans, inbuf, *outbuf);
2124       else
2125         ret = GST_FLOW_NOT_SUPPORTED;
2126     }
2127   }
2128
2129   /* only unref input buffer if we allocated a new outbuf buffer. If we reused
2130    * the input buffer, no refcount is changed to keep the input buffer writable
2131    * when needed. */
2132   if (*outbuf != inbuf)
2133     gst_buffer_unref (inbuf);
2134
2135   return ret;
2136
2137   /* ERRORS */
2138 no_prepare:
2139   {
2140     gst_buffer_unref (inbuf);
2141     GST_ELEMENT_ERROR (trans, STREAM, NOT_IMPLEMENTED,
2142         ("Sub-class has no prepare_output_buffer implementation"), (NULL));
2143     return GST_FLOW_NOT_SUPPORTED;
2144   }
2145 no_buffer:
2146   {
2147     gst_buffer_unref (inbuf);
2148     *outbuf = NULL;
2149     GST_WARNING_OBJECT (trans, "could not get buffer from pool: %s",
2150         gst_flow_get_name (ret));
2151     return ret;
2152   }
2153 }
2154
2155 /* FIXME, getrange is broken, need to pull range from the other
2156  * end based on the transform_size result.
2157  */
2158 static GstFlowReturn
2159 gst_base_transform_getrange (GstPad * pad, GstObject * parent, guint64 offset,
2160     guint length, GstBuffer ** buffer)
2161 {
2162   GstBaseTransformClass *klass = GST_BASE_TRANSFORM_GET_CLASS (parent);
2163   GstBaseTransform *trans = GST_BASE_TRANSFORM (parent);
2164   GstBaseTransformPrivate *priv = trans->priv;
2165   GstFlowReturn ret;
2166   GstBuffer *inbuf = NULL;
2167   GstBuffer *outbuf = NULL;
2168
2169   /* Try and generate a buffer, if the sub-class wants more data,
2170    * pull some and repeat until a buffer (or error) is produced */
2171   do {
2172     ret = klass->generate_output (trans, &outbuf);
2173
2174     /* Consume the DROPPED return value and go get more data */
2175     if (ret == GST_BASE_TRANSFORM_FLOW_DROPPED)
2176       ret = GST_FLOW_OK;
2177
2178     if (ret != GST_FLOW_OK || outbuf != NULL)
2179       break;
2180
2181     /* No buffer generated, try and pull data */
2182     ret = gst_pad_pull_range (trans->sinkpad, offset, length, &inbuf);
2183     if (G_UNLIKELY (ret != GST_FLOW_OK))
2184       goto pull_error;
2185
2186     if (klass->before_transform)
2187       klass->before_transform (trans, inbuf);
2188
2189     /* Set discont flag so we can mark the next outgoing buffer */
2190     if (GST_BUFFER_IS_DISCONT (inbuf)) {
2191       GST_DEBUG_OBJECT (trans, "got DISCONT buffer %p", inbuf);
2192       priv->discont = TRUE;
2193     }
2194
2195     /* FIXME: Input offsets and lengths need to be translated, as per
2196      * the FIXME above. For now, just advance somewhat */
2197     offset += gst_buffer_get_size (inbuf);
2198
2199     ret = klass->submit_input_buffer (trans, priv->discont, inbuf);
2200     if (ret != GST_FLOW_OK) {
2201       if (ret == GST_BASE_TRANSFORM_FLOW_DROPPED)
2202         ret = GST_FLOW_OK;
2203       goto done;
2204     }
2205   } while (ret == GST_FLOW_OK && outbuf == NULL);
2206
2207   *buffer = outbuf;
2208   if (outbuf) {
2209     /* apply DISCONT flag if the buffer is not yet marked as such */
2210     if (priv->discont) {
2211       GST_DEBUG_OBJECT (trans, "we have a pending DISCONT");
2212       if (!GST_BUFFER_IS_DISCONT (outbuf)) {
2213         GST_DEBUG_OBJECT (trans, "marking DISCONT on output buffer");
2214         outbuf = gst_buffer_make_writable (outbuf);
2215         GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
2216       }
2217       priv->discont = FALSE;
2218     }
2219     priv->processed++;
2220   }
2221 done:
2222   return ret;
2223
2224   /* ERRORS */
2225 pull_error:
2226   {
2227     GST_DEBUG_OBJECT (trans, "failed to pull a buffer: %s",
2228         gst_flow_get_name (ret));
2229     goto done;
2230   }
2231 }
2232
2233 /* The flow of the chain function is the reverse of the
2234  * getrange() function - we have data, feed it to the sub-class
2235  * and then iterate, pushing buffers it generates until it either
2236  * wants more data or returns an error */
2237 static GstFlowReturn
2238 gst_base_transform_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
2239 {
2240   GstBaseTransform *trans = GST_BASE_TRANSFORM (parent);
2241   GstBaseTransformClass *klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2242   GstBaseTransformPrivate *priv = trans->priv;
2243   GstFlowReturn ret;
2244   GstClockTime position = GST_CLOCK_TIME_NONE;
2245   GstClockTime timestamp, duration;
2246   GstBuffer *outbuf = NULL;
2247
2248   timestamp = GST_BUFFER_TIMESTAMP (buffer);
2249   duration = GST_BUFFER_DURATION (buffer);
2250
2251   /* calculate end position of the incoming buffer */
2252   if (timestamp != GST_CLOCK_TIME_NONE) {
2253     if (duration != GST_CLOCK_TIME_NONE)
2254       position = timestamp + duration;
2255     else
2256       position = timestamp;
2257   }
2258
2259   if (klass->before_transform)
2260     klass->before_transform (trans, buffer);
2261
2262   /* Set discont flag so we can mark the outgoing buffer */
2263   if (GST_BUFFER_IS_DISCONT (buffer)) {
2264     GST_DEBUG_OBJECT (trans, "got DISCONT buffer %p", buffer);
2265     priv->discont = TRUE;
2266   }
2267
2268   /* Takes ownership of input buffer */
2269   ret = klass->submit_input_buffer (trans, priv->discont, buffer);
2270   if (ret != GST_FLOW_OK)
2271     goto done;
2272
2273   do {
2274     outbuf = NULL;
2275
2276     ret = klass->generate_output (trans, &outbuf);
2277
2278     /* outbuf can be NULL, this means a dropped buffer, if we have a buffer but
2279      * GST_BASE_TRANSFORM_FLOW_DROPPED we will not push either. */
2280     if (outbuf != NULL) {
2281       if (ret == GST_FLOW_OK) {
2282         GstClockTime position_out = GST_CLOCK_TIME_NONE;
2283
2284         /* Remember last stop position */
2285         if (position != GST_CLOCK_TIME_NONE &&
2286             trans->segment.format == GST_FORMAT_TIME)
2287           trans->segment.position = position;
2288
2289         if (GST_BUFFER_TIMESTAMP_IS_VALID (outbuf)) {
2290           position_out = GST_BUFFER_TIMESTAMP (outbuf);
2291           if (GST_BUFFER_DURATION_IS_VALID (outbuf))
2292             position_out += GST_BUFFER_DURATION (outbuf);
2293         } else if (position != GST_CLOCK_TIME_NONE) {
2294           position_out = position;
2295         }
2296         if (position_out != GST_CLOCK_TIME_NONE
2297             && trans->segment.format == GST_FORMAT_TIME)
2298           priv->position_out = position_out;
2299
2300         /* apply DISCONT flag if the buffer is not yet marked as such */
2301         if (trans->priv->discont) {
2302           GST_DEBUG_OBJECT (trans, "we have a pending DISCONT");
2303           if (!GST_BUFFER_IS_DISCONT (outbuf)) {
2304             GST_DEBUG_OBJECT (trans, "marking DISCONT on output buffer");
2305             outbuf = gst_buffer_make_writable (outbuf);
2306             GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
2307           }
2308           priv->discont = FALSE;
2309         }
2310         priv->processed++;
2311
2312         ret = gst_pad_push (trans->srcpad, outbuf);
2313       } else {
2314         GST_DEBUG_OBJECT (trans, "we got return %s", gst_flow_get_name (ret));
2315         gst_buffer_unref (outbuf);
2316       }
2317     }
2318   } while (ret == GST_FLOW_OK && outbuf != NULL);
2319
2320 done:
2321   /* convert internal flow to OK and mark discont for the next buffer. */
2322   if (ret == GST_BASE_TRANSFORM_FLOW_DROPPED) {
2323     GST_DEBUG_OBJECT (trans, "dropped a buffer, marking DISCONT");
2324     priv->discont = TRUE;
2325     ret = GST_FLOW_OK;
2326   }
2327
2328   return ret;
2329 }
2330
2331 static void
2332 gst_base_transform_set_property (GObject * object, guint prop_id,
2333     const GValue * value, GParamSpec * pspec)
2334 {
2335   GstBaseTransform *trans;
2336
2337   trans = GST_BASE_TRANSFORM (object);
2338
2339   switch (prop_id) {
2340     case PROP_QOS:
2341       gst_base_transform_set_qos_enabled (trans, g_value_get_boolean (value));
2342       break;
2343     default:
2344       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2345       break;
2346   }
2347 }
2348
2349 static void
2350 gst_base_transform_get_property (GObject * object, guint prop_id,
2351     GValue * value, GParamSpec * pspec)
2352 {
2353   GstBaseTransform *trans;
2354
2355   trans = GST_BASE_TRANSFORM (object);
2356
2357   switch (prop_id) {
2358     case PROP_QOS:
2359       g_value_set_boolean (value, gst_base_transform_is_qos_enabled (trans));
2360       break;
2361     default:
2362       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2363       break;
2364   }
2365 }
2366
2367 /* not a vmethod of anything, just an internal method */
2368 static gboolean
2369 gst_base_transform_activate (GstBaseTransform * trans, gboolean active)
2370 {
2371   GstBaseTransformClass *bclass;
2372   GstBaseTransformPrivate *priv = trans->priv;
2373   gboolean result = TRUE;
2374
2375   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2376
2377   if (active) {
2378     GstCaps *incaps, *outcaps;
2379
2380     if (priv->pad_mode == GST_PAD_MODE_NONE && bclass->start)
2381       result &= bclass->start (trans);
2382
2383     incaps = gst_pad_get_current_caps (trans->sinkpad);
2384     outcaps = gst_pad_get_current_caps (trans->srcpad);
2385
2386     GST_OBJECT_LOCK (trans);
2387     if (incaps && outcaps)
2388       priv->have_same_caps =
2389           gst_caps_is_equal (incaps, outcaps) || priv->passthrough;
2390     else
2391       priv->have_same_caps = priv->passthrough;
2392     GST_DEBUG_OBJECT (trans, "have_same_caps %d", priv->have_same_caps);
2393     priv->negotiated = FALSE;
2394     trans->have_segment = FALSE;
2395     gst_segment_init (&trans->segment, GST_FORMAT_UNDEFINED);
2396     priv->position_out = GST_CLOCK_TIME_NONE;
2397     priv->proportion = 1.0;
2398     priv->earliest_time = -1;
2399     priv->discont = FALSE;
2400     priv->processed = 0;
2401     priv->dropped = 0;
2402     GST_OBJECT_UNLOCK (trans);
2403
2404     if (incaps)
2405       gst_caps_unref (incaps);
2406     if (outcaps)
2407       gst_caps_unref (outcaps);
2408   } else {
2409     /* We must make sure streaming has finished before resetting things
2410      * and calling the ::stop vfunc */
2411     GST_PAD_STREAM_LOCK (trans->sinkpad);
2412     GST_PAD_STREAM_UNLOCK (trans->sinkpad);
2413
2414     priv->have_same_caps = FALSE;
2415     /* We can only reset the passthrough mode if the instance told us to
2416        handle it in configure_caps */
2417     if (bclass->passthrough_on_same_caps) {
2418       gst_base_transform_set_passthrough (trans, FALSE);
2419     }
2420     gst_caps_replace (&priv->cache_caps1, NULL);
2421     gst_caps_replace (&priv->cache_caps2, NULL);
2422
2423     /* Make sure any left over buffer is freed */
2424     gst_buffer_replace (&trans->queued_buf, NULL);
2425
2426     if (priv->pad_mode != GST_PAD_MODE_NONE && bclass->stop)
2427       result &= bclass->stop (trans);
2428
2429     gst_base_transform_set_allocation (trans, NULL, NULL, NULL, NULL);
2430   }
2431
2432   return result;
2433 }
2434
2435 static gboolean
2436 gst_base_transform_sink_activate_mode (GstPad * pad, GstObject * parent,
2437     GstPadMode mode, gboolean active)
2438 {
2439   gboolean result = FALSE;
2440   GstBaseTransform *trans;
2441
2442   trans = GST_BASE_TRANSFORM (parent);
2443
2444   switch (mode) {
2445     case GST_PAD_MODE_PUSH:
2446     {
2447       result = gst_base_transform_activate (trans, active);
2448
2449       if (result)
2450         trans->priv->pad_mode = active ? GST_PAD_MODE_PUSH : GST_PAD_MODE_NONE;
2451
2452       break;
2453     }
2454     default:
2455       result = TRUE;
2456       break;
2457   }
2458   return result;
2459 }
2460
2461 static gboolean
2462 gst_base_transform_src_activate_mode (GstPad * pad, GstObject * parent,
2463     GstPadMode mode, gboolean active)
2464 {
2465   gboolean result = FALSE;
2466   GstBaseTransform *trans;
2467
2468   trans = GST_BASE_TRANSFORM (parent);
2469
2470   switch (mode) {
2471     case GST_PAD_MODE_PULL:
2472     {
2473       result =
2474           gst_pad_activate_mode (trans->sinkpad, GST_PAD_MODE_PULL, active);
2475
2476       if (result)
2477         result &= gst_base_transform_activate (trans, active);
2478
2479       if (result)
2480         trans->priv->pad_mode = active ? mode : GST_PAD_MODE_NONE;
2481       break;
2482     }
2483     default:
2484       result = TRUE;
2485       break;
2486   }
2487
2488   return result;
2489 }
2490
2491 /**
2492  * gst_base_transform_set_passthrough:
2493  * @trans: the #GstBaseTransform to set
2494  * @passthrough: boolean indicating passthrough mode.
2495  *
2496  * Set passthrough mode for this filter by default. This is mostly
2497  * useful for filters that do not care about negotiation.
2498  *
2499  * Always %TRUE for filters which don't implement either a transform
2500  * or transform_ip method.
2501  *
2502  * MT safe.
2503  */
2504 void
2505 gst_base_transform_set_passthrough (GstBaseTransform * trans,
2506     gboolean passthrough)
2507 {
2508   GstBaseTransformClass *bclass;
2509
2510   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2511
2512   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2513
2514   GST_OBJECT_LOCK (trans);
2515   if (!passthrough) {
2516     if (bclass->transform_ip || bclass->transform)
2517       trans->priv->passthrough = FALSE;
2518   } else {
2519     trans->priv->passthrough = TRUE;
2520   }
2521
2522   GST_DEBUG_OBJECT (trans, "set passthrough %d", trans->priv->passthrough);
2523   GST_OBJECT_UNLOCK (trans);
2524 }
2525
2526 /**
2527  * gst_base_transform_is_passthrough:
2528  * @trans: the #GstBaseTransform to query
2529  *
2530  * See if @trans is configured as a passthrough transform.
2531  *
2532  * Returns: %TRUE is the transform is configured in passthrough mode.
2533  *
2534  * MT safe.
2535  */
2536 gboolean
2537 gst_base_transform_is_passthrough (GstBaseTransform * trans)
2538 {
2539   gboolean result;
2540
2541   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), FALSE);
2542
2543   GST_OBJECT_LOCK (trans);
2544   result = trans->priv->passthrough;
2545   GST_OBJECT_UNLOCK (trans);
2546
2547   return result;
2548 }
2549
2550 /**
2551  * gst_base_transform_set_in_place:
2552  * @trans: the #GstBaseTransform to modify
2553  * @in_place: Boolean value indicating that we would like to operate
2554  * on in_place buffers.
2555  *
2556  * Determines whether a non-writable buffer will be copied before passing
2557  * to the transform_ip function.
2558  *
2559  *   * Always %TRUE if no transform function is implemented.
2560  *   * Always %FALSE if ONLY transform function is implemented.
2561  *
2562  * MT safe.
2563  */
2564 void
2565 gst_base_transform_set_in_place (GstBaseTransform * trans, gboolean in_place)
2566 {
2567   GstBaseTransformClass *bclass;
2568
2569   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2570
2571   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2572
2573   GST_OBJECT_LOCK (trans);
2574
2575   if (in_place) {
2576     if (bclass->transform_ip) {
2577       GST_DEBUG_OBJECT (trans, "setting in_place TRUE");
2578       trans->priv->always_in_place = TRUE;
2579     }
2580   } else {
2581     if (bclass->transform) {
2582       GST_DEBUG_OBJECT (trans, "setting in_place FALSE");
2583       trans->priv->always_in_place = FALSE;
2584     }
2585   }
2586
2587   GST_OBJECT_UNLOCK (trans);
2588 }
2589
2590 /**
2591  * gst_base_transform_is_in_place:
2592  * @trans: the #GstBaseTransform to query
2593  *
2594  * See if @trans is configured as a in_place transform.
2595  *
2596  * Returns: %TRUE is the transform is configured in in_place mode.
2597  *
2598  * MT safe.
2599  */
2600 gboolean
2601 gst_base_transform_is_in_place (GstBaseTransform * trans)
2602 {
2603   gboolean result;
2604
2605   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), FALSE);
2606
2607   GST_OBJECT_LOCK (trans);
2608   result = trans->priv->always_in_place;
2609   GST_OBJECT_UNLOCK (trans);
2610
2611   return result;
2612 }
2613
2614 /**
2615  * gst_base_transform_update_qos:
2616  * @trans: a #GstBaseTransform
2617  * @proportion: the proportion
2618  * @diff: the diff against the clock
2619  * @timestamp: the timestamp of the buffer generating the QoS expressed in
2620  * running_time.
2621  *
2622  * Set the QoS parameters in the transform. This function is called internally
2623  * when a QOS event is received but subclasses can provide custom information
2624  * when needed.
2625  *
2626  * MT safe.
2627  */
2628 void
2629 gst_base_transform_update_qos (GstBaseTransform * trans,
2630     gdouble proportion, GstClockTimeDiff diff, GstClockTime timestamp)
2631 {
2632   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2633
2634   GST_CAT_DEBUG_OBJECT (GST_CAT_QOS, trans,
2635       "qos: proportion: %lf, diff %" G_GINT64_FORMAT ", timestamp %"
2636       GST_TIME_FORMAT, proportion, diff, GST_TIME_ARGS (timestamp));
2637
2638   GST_OBJECT_LOCK (trans);
2639   trans->priv->proportion = proportion;
2640   trans->priv->earliest_time = timestamp + diff;
2641   GST_OBJECT_UNLOCK (trans);
2642 }
2643
2644 /**
2645  * gst_base_transform_set_qos_enabled:
2646  * @trans: a #GstBaseTransform
2647  * @enabled: new state
2648  *
2649  * Enable or disable QoS handling in the transform.
2650  *
2651  * MT safe.
2652  */
2653 void
2654 gst_base_transform_set_qos_enabled (GstBaseTransform * trans, gboolean enabled)
2655 {
2656   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2657
2658   GST_CAT_DEBUG_OBJECT (GST_CAT_QOS, trans, "enabled: %d", enabled);
2659
2660   GST_OBJECT_LOCK (trans);
2661   trans->priv->qos_enabled = enabled;
2662   GST_OBJECT_UNLOCK (trans);
2663 }
2664
2665 /**
2666  * gst_base_transform_is_qos_enabled:
2667  * @trans: a #GstBaseTransform
2668  *
2669  * Queries if the transform will handle QoS.
2670  *
2671  * Returns: %TRUE if QoS is enabled.
2672  *
2673  * MT safe.
2674  */
2675 gboolean
2676 gst_base_transform_is_qos_enabled (GstBaseTransform * trans)
2677 {
2678   gboolean result;
2679
2680   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), FALSE);
2681
2682   GST_OBJECT_LOCK (trans);
2683   result = trans->priv->qos_enabled;
2684   GST_OBJECT_UNLOCK (trans);
2685
2686   return result;
2687 }
2688
2689 /**
2690  * gst_base_transform_set_gap_aware:
2691  * @trans: a #GstBaseTransform
2692  * @gap_aware: New state
2693  *
2694  * If @gap_aware is %FALSE (the default), output buffers will have the
2695  * %GST_BUFFER_FLAG_GAP flag unset.
2696  *
2697  * If set to %TRUE, the element must handle output buffers with this flag set
2698  * correctly, i.e. it can assume that the buffer contains neutral data but must
2699  * unset the flag if the output is no neutral data.
2700  *
2701  * MT safe.
2702  */
2703 void
2704 gst_base_transform_set_gap_aware (GstBaseTransform * trans, gboolean gap_aware)
2705 {
2706   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2707
2708   GST_OBJECT_LOCK (trans);
2709   trans->priv->gap_aware = gap_aware;
2710   GST_DEBUG_OBJECT (trans, "set gap aware %d", trans->priv->gap_aware);
2711   GST_OBJECT_UNLOCK (trans);
2712 }
2713
2714 /**
2715  * gst_base_transform_set_prefer_passthrough:
2716  * @trans: a #GstBaseTransform
2717  * @prefer_passthrough: New state
2718  *
2719  * If @prefer_passthrough is %TRUE (the default), @trans will check and
2720  * prefer passthrough caps from the list of caps returned by the
2721  * transform_caps vmethod.
2722  *
2723  * If set to %FALSE, the element must order the caps returned from the
2724  * transform_caps function in such a way that the preferred format is
2725  * first in the list. This can be interesting for transforms that can do
2726  * passthrough transforms but prefer to do something else, like a
2727  * capsfilter.
2728  *
2729  * MT safe.
2730  *
2731  * Since: 1.0.1
2732  */
2733 void
2734 gst_base_transform_set_prefer_passthrough (GstBaseTransform * trans,
2735     gboolean prefer_passthrough)
2736 {
2737   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2738
2739   GST_OBJECT_LOCK (trans);
2740   trans->priv->prefer_passthrough = prefer_passthrough;
2741   GST_DEBUG_OBJECT (trans, "prefer passthrough %d", prefer_passthrough);
2742   GST_OBJECT_UNLOCK (trans);
2743 }
2744
2745 /**
2746  * gst_base_transform_reconfigure_sink:
2747  * @trans: a #GstBaseTransform
2748  *
2749  * Instructs @trans to request renegotiation upstream. This function is
2750  * typically called after properties on the transform were set that
2751  * influence the input format.
2752  */
2753 void
2754 gst_base_transform_reconfigure_sink (GstBaseTransform * trans)
2755 {
2756   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2757
2758   /* push the renegotiate event */
2759   if (!gst_pad_push_event (GST_BASE_TRANSFORM_SINK_PAD (trans),
2760           gst_event_new_reconfigure ()))
2761     GST_DEBUG_OBJECT (trans, "Renegotiate event wasn't handled");
2762 }
2763
2764 /**
2765  * gst_base_transform_reconfigure_src:
2766  * @trans: a #GstBaseTransform
2767  *
2768  * Instructs @trans to renegotiate a new downstream transform on the next
2769  * buffer. This function is typically called after properties on the transform
2770  * were set that influence the output format.
2771  */
2772 void
2773 gst_base_transform_reconfigure_src (GstBaseTransform * trans)
2774 {
2775   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2776
2777   gst_pad_mark_reconfigure (trans->srcpad);
2778 }
2779
2780 /**
2781  * gst_base_transform_get_buffer_pool:
2782  * @trans: a #GstBaseTransform
2783  *
2784  * Returns: (transfer full): the instance of the #GstBufferPool used
2785  * by @trans; free it after use it
2786  */
2787 GstBufferPool *
2788 gst_base_transform_get_buffer_pool (GstBaseTransform * trans)
2789 {
2790   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), NULL);
2791
2792   if (trans->priv->pool)
2793     return gst_object_ref (trans->priv->pool);
2794
2795   return NULL;
2796 }
2797
2798 /**
2799  * gst_base_transform_get_allocator:
2800  * @trans: a #GstBaseTransform
2801  * @allocator: (out) (allow-none) (transfer full): the #GstAllocator
2802  * used
2803  * @params: (out) (allow-none) (transfer full): the
2804  * #GstAllocationParams of @allocator
2805  *
2806  * Lets #GstBaseTransform sub-classes to know the memory @allocator
2807  * used by the base class and its @params.
2808  *
2809  * Unref the @allocator after use it.
2810  */
2811 void
2812 gst_base_transform_get_allocator (GstBaseTransform * trans,
2813     GstAllocator ** allocator, GstAllocationParams * params)
2814 {
2815   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2816
2817   if (allocator)
2818     *allocator = trans->priv->allocator ?
2819         gst_object_ref (trans->priv->allocator) : NULL;
2820
2821   if (params)
2822     *params = trans->priv->params;
2823 }
2824
2825 /**
2826  * gst_base_transform_update_src_caps:
2827  * @trans: a #GstBaseTransform
2828  * @updated_caps: An updated version of the srcpad caps to be pushed
2829  * downstream
2830  *
2831  * Updates the srcpad caps and send the caps downstream. This function
2832  * can be used by subclasses when they have already negotiated their caps
2833  * but found a change in them (or computed new informations). This way,
2834  * they can notify downstream about that change without loosing any
2835  * buffer.
2836  *
2837  * Returns: %TRUE if the caps could be send downstream %FALSE otherwise
2838  *
2839  * Since: 1.6
2840  */
2841 gboolean
2842 gst_base_transform_update_src_caps (GstBaseTransform * trans,
2843     GstCaps * updated_caps)
2844 {
2845   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), FALSE);
2846
2847   if (gst_pad_push_event (GST_BASE_TRANSFORM_SRC_PAD (trans),
2848           gst_event_new_caps (updated_caps))) {
2849     gst_pad_mark_reconfigure (trans->srcpad);
2850
2851     return TRUE;
2852   }
2853
2854   return FALSE;
2855 }