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