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   gboolean ret = TRUE;
1293
1294 #if 0
1295   otherpad = (pad == trans->srcpad) ? trans->sinkpad : trans->srcpad;
1296
1297   /* we need fixed caps for the check, fall back to the default implementation
1298    * if we don't */
1299   if (!gst_caps_is_fixed (caps))
1300 #endif
1301   {
1302     GstCaps *allowed;
1303
1304     GST_DEBUG_OBJECT (trans, "accept caps %" GST_PTR_FORMAT, caps);
1305
1306     /* get all the formats we can handle on this pad */
1307     if (direction == GST_PAD_SRC)
1308       allowed = gst_pad_query_caps (trans->srcpad, caps);
1309     else
1310       allowed = gst_pad_query_caps (trans->sinkpad, caps);
1311
1312     if (!allowed) {
1313       GST_DEBUG_OBJECT (trans, "gst_pad_query_caps() failed");
1314       goto no_transform_possible;
1315     }
1316
1317     GST_DEBUG_OBJECT (trans, "allowed caps %" GST_PTR_FORMAT, allowed);
1318
1319     /* intersect with the requested format */
1320     ret = gst_caps_is_subset (caps, allowed);
1321     gst_caps_unref (allowed);
1322
1323     if (!ret)
1324       goto no_transform_possible;
1325   }
1326 #if 0
1327   else {
1328     GST_DEBUG_OBJECT (pad, "accept caps %" GST_PTR_FORMAT, caps);
1329
1330     /* find best possible caps for the other pad as a way to see if we can
1331      * transform this caps. */
1332     othercaps = gst_base_transform_find_transform (trans, pad, caps, FALSE);
1333     if (!othercaps || gst_caps_is_empty (othercaps))
1334       goto no_transform_possible;
1335
1336     GST_DEBUG_OBJECT (pad, "we can transform to %" GST_PTR_FORMAT, othercaps);
1337   }
1338 #endif
1339
1340 done:
1341 #if 0
1342   /* We know it's always NULL since we never use it */
1343   if (othercaps)
1344     gst_caps_unref (othercaps);
1345 #endif
1346
1347   return ret;
1348
1349   /* ERRORS */
1350 no_transform_possible:
1351   {
1352     GST_DEBUG_OBJECT (trans,
1353         "transform could not transform %" GST_PTR_FORMAT
1354         " in anything we support", caps);
1355     ret = FALSE;
1356     goto done;
1357   }
1358 }
1359
1360 /* called when new caps arrive on the sink pad,
1361  * We try to find the best caps for the other side using our _find_transform()
1362  * function. If there are caps, we configure the transform for this new
1363  * transformation.
1364  */
1365 static gboolean
1366 gst_base_transform_setcaps (GstBaseTransform * trans, GstPad * pad,
1367     GstCaps * incaps)
1368 {
1369   GstBaseTransformPrivate *priv = trans->priv;
1370   GstCaps *outcaps, *prev_incaps = NULL, *prev_outcaps = NULL;
1371   gboolean ret = TRUE;
1372
1373   GST_DEBUG_OBJECT (pad, "have new caps %p %" GST_PTR_FORMAT, incaps, incaps);
1374
1375   /* find best possible caps for the other pad */
1376   outcaps = gst_base_transform_find_transform (trans, pad, incaps);
1377   if (!outcaps || gst_caps_is_empty (outcaps))
1378     goto no_transform_possible;
1379
1380   /* configure the element now */
1381
1382   /* if we have the same caps, we can optimize and reuse the input caps */
1383   if (gst_caps_is_equal (incaps, outcaps)) {
1384     GST_INFO_OBJECT (trans, "reuse caps");
1385     gst_caps_unref (outcaps);
1386     outcaps = gst_caps_ref (incaps);
1387   }
1388
1389   prev_incaps = gst_pad_get_current_caps (trans->sinkpad);
1390   prev_outcaps = gst_pad_get_current_caps (trans->srcpad);
1391   if (prev_incaps && prev_outcaps && gst_caps_is_equal (prev_incaps, incaps)
1392       && gst_caps_is_equal (prev_outcaps, outcaps)) {
1393     GST_DEBUG_OBJECT (trans,
1394         "New caps equal to old ones: %" GST_PTR_FORMAT " -> %" GST_PTR_FORMAT,
1395         incaps, outcaps);
1396     ret = TRUE;
1397   } else {
1398     /* call configure now */
1399     if (!(ret = gst_base_transform_configure_caps (trans, incaps, outcaps)))
1400       goto failed_configure;
1401
1402     if (!prev_outcaps || !gst_caps_is_equal (outcaps, prev_outcaps))
1403       /* let downstream know about our caps */
1404       ret = gst_pad_set_caps (trans->srcpad, outcaps);
1405   }
1406
1407   if (ret) {
1408     /* try to get a pool when needed */
1409     ret = gst_base_transform_do_bufferpool (trans, outcaps);
1410   }
1411
1412 done:
1413   if (outcaps)
1414     gst_caps_unref (outcaps);
1415   if (prev_incaps)
1416     gst_caps_unref (prev_incaps);
1417   if (prev_outcaps)
1418     gst_caps_unref (prev_outcaps);
1419
1420   GST_OBJECT_LOCK (trans);
1421   priv->negotiated = ret;
1422   GST_OBJECT_UNLOCK (trans);
1423
1424   return ret;
1425
1426   /* ERRORS */
1427 no_transform_possible:
1428   {
1429     GST_WARNING_OBJECT (trans,
1430         "transform could not transform %" GST_PTR_FORMAT
1431         " in anything we support", incaps);
1432     ret = FALSE;
1433     goto done;
1434   }
1435 failed_configure:
1436   {
1437     GST_WARNING_OBJECT (trans, "FAILED to configure incaps %" GST_PTR_FORMAT
1438         " and outcaps %" GST_PTR_FORMAT, incaps, outcaps);
1439     ret = FALSE;
1440     goto done;
1441   }
1442 }
1443
1444 static gboolean
1445 gst_base_transform_default_propose_allocation (GstBaseTransform * trans,
1446     GstQuery * decide_query, GstQuery * query)
1447 {
1448   gboolean ret;
1449
1450   if (decide_query == NULL) {
1451     GST_DEBUG_OBJECT (trans, "doing passthrough query");
1452     ret = gst_pad_peer_query (trans->srcpad, query);
1453   } else {
1454     guint i, n_metas;
1455     /* non-passthrough, copy all metadata, decide_query does not contain the
1456      * metadata anymore that depends on the buffer memory */
1457     n_metas = gst_query_get_n_allocation_metas (decide_query);
1458     for (i = 0; i < n_metas; i++) {
1459       GType api;
1460       const GstStructure *params;
1461
1462       api = gst_query_parse_nth_allocation_meta (decide_query, i, &params);
1463       GST_DEBUG_OBJECT (trans, "proposing metadata %s", g_type_name (api));
1464       gst_query_add_allocation_meta (query, api, params);
1465     }
1466     ret = TRUE;
1467   }
1468   return ret;
1469 }
1470
1471 static gboolean
1472 gst_base_transform_default_query (GstBaseTransform * trans,
1473     GstPadDirection direction, GstQuery * query)
1474 {
1475   gboolean ret = FALSE;
1476   GstPad *pad, *otherpad;
1477   GstBaseTransformClass *klass;
1478   GstBaseTransformPrivate *priv = trans->priv;
1479
1480   if (direction == GST_PAD_SRC) {
1481     pad = trans->srcpad;
1482     otherpad = trans->sinkpad;
1483   } else {
1484     pad = trans->sinkpad;
1485     otherpad = trans->srcpad;
1486   }
1487
1488   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1489
1490   switch (GST_QUERY_TYPE (query)) {
1491     case GST_QUERY_ALLOCATION:
1492     {
1493       GstQuery *decide_query = NULL;
1494
1495       /* can only be done on the sinkpad */
1496       if (direction != GST_PAD_SINK)
1497         goto done;
1498
1499       GST_OBJECT_LOCK (trans);
1500       if (!priv->negotiated && !priv->passthrough && (klass->set_caps != NULL)) {
1501         GST_DEBUG_OBJECT (trans,
1502             "not negotiated yet but need negotiation, can't answer ALLOCATION query");
1503         GST_OBJECT_UNLOCK (trans);
1504         goto done;
1505       }
1506
1507       decide_query = trans->priv->query;
1508       trans->priv->query = NULL;
1509
1510       GST_OBJECT_UNLOCK (trans);
1511
1512       GST_DEBUG_OBJECT (trans,
1513           "calling propose allocation with query %" GST_PTR_FORMAT,
1514           decide_query);
1515
1516       /* pass the query to the propose_allocation vmethod if any */
1517       if (G_LIKELY (klass->propose_allocation))
1518         ret = klass->propose_allocation (trans, decide_query, query);
1519       else
1520         ret = FALSE;
1521
1522       if (decide_query) {
1523         GST_OBJECT_LOCK (trans);
1524
1525         if (trans->priv->query == NULL)
1526           trans->priv->query = decide_query;
1527         else
1528           gst_query_unref (decide_query);
1529
1530         GST_OBJECT_UNLOCK (trans);
1531       }
1532
1533       GST_DEBUG_OBJECT (trans, "ALLOCATION ret %d, %" GST_PTR_FORMAT, ret,
1534           query);
1535       break;
1536     }
1537     case GST_QUERY_POSITION:
1538     {
1539       GstFormat format;
1540
1541       gst_query_parse_position (query, &format, NULL);
1542       if (format == GST_FORMAT_TIME && trans->segment.format == GST_FORMAT_TIME) {
1543         gint64 pos;
1544         ret = TRUE;
1545
1546         if ((direction == GST_PAD_SINK)
1547             || (trans->priv->position_out == GST_CLOCK_TIME_NONE)) {
1548           pos =
1549               gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME,
1550               trans->segment.position);
1551         } else {
1552           pos = gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME,
1553               trans->priv->position_out);
1554         }
1555         gst_query_set_position (query, format, pos);
1556       } else {
1557         ret = gst_pad_peer_query (otherpad, query);
1558       }
1559       break;
1560     }
1561     case GST_QUERY_ACCEPT_CAPS:
1562     {
1563       GstCaps *caps;
1564
1565       gst_query_parse_accept_caps (query, &caps);
1566       if (klass->accept_caps) {
1567         ret = klass->accept_caps (trans, direction, caps);
1568         gst_query_set_accept_caps_result (query, ret);
1569         /* return TRUE, we answered the query */
1570         ret = TRUE;
1571       }
1572       break;
1573     }
1574     case GST_QUERY_CAPS:
1575     {
1576       GstCaps *filter, *caps;
1577
1578       gst_query_parse_caps (query, &filter);
1579       caps = gst_base_transform_query_caps (trans, pad, filter);
1580       gst_query_set_caps_result (query, caps);
1581       gst_caps_unref (caps);
1582       ret = TRUE;
1583       break;
1584     }
1585     default:
1586       ret = gst_pad_peer_query (otherpad, query);
1587       break;
1588   }
1589
1590 done:
1591   return ret;
1592 }
1593
1594 static gboolean
1595 gst_base_transform_query (GstPad * pad, GstObject * parent, GstQuery * query)
1596 {
1597   GstBaseTransform *trans;
1598   GstBaseTransformClass *bclass;
1599   gboolean ret = FALSE;
1600
1601   trans = GST_BASE_TRANSFORM (parent);
1602   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1603
1604   if (bclass->query)
1605     ret = bclass->query (trans, GST_PAD_DIRECTION (pad), query);
1606
1607   return ret;
1608 }
1609
1610 /* this function either returns the input buffer without incrementing the
1611  * refcount or it allocates a new (writable) buffer */
1612 static GstFlowReturn
1613 default_prepare_output_buffer (GstBaseTransform * trans,
1614     GstBuffer * inbuf, GstBuffer ** outbuf)
1615 {
1616   GstBaseTransformPrivate *priv;
1617   GstFlowReturn ret;
1618   GstBaseTransformClass *bclass;
1619   GstCaps *incaps, *outcaps;
1620   gsize insize, outsize;
1621   gboolean res;
1622
1623   priv = trans->priv;
1624   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1625
1626   /* figure out how to allocate an output buffer */
1627   if (priv->passthrough) {
1628     /* passthrough, we will not modify the incoming buffer so we can just
1629      * reuse it */
1630     GST_DEBUG_OBJECT (trans, "passthrough: reusing input buffer");
1631     *outbuf = inbuf;
1632     goto done;
1633   }
1634
1635   /* we can't reuse the input buffer */
1636   if (priv->pool) {
1637     if (!priv->pool_active) {
1638       GST_DEBUG_OBJECT (trans, "setting pool %p active", priv->pool);
1639       if (!gst_buffer_pool_set_active (priv->pool, TRUE))
1640         goto activate_failed;
1641       priv->pool_active = TRUE;
1642     }
1643     GST_DEBUG_OBJECT (trans, "using pool alloc");
1644     ret = gst_buffer_pool_acquire_buffer (priv->pool, outbuf, NULL);
1645     if (ret != GST_FLOW_OK)
1646       goto alloc_failed;
1647
1648     goto copy_meta;
1649   }
1650
1651   /* no pool, we need to figure out the size of the output buffer first */
1652   if ((bclass->transform_ip != NULL) && priv->always_in_place) {
1653     /* we want to do an in-place alloc */
1654     if (gst_buffer_is_writable (inbuf)) {
1655       GST_DEBUG_OBJECT (trans, "inplace reuse writable input buffer");
1656       *outbuf = inbuf;
1657     } else {
1658       GST_DEBUG_OBJECT (trans, "making writable buffer copy");
1659       /* we make a copy of the input buffer */
1660       *outbuf = gst_buffer_copy (inbuf);
1661     }
1662     goto done;
1663   }
1664
1665   /* else use the transform function to get the size */
1666   incaps = gst_pad_get_current_caps (trans->sinkpad);
1667   outcaps = gst_pad_get_current_caps (trans->srcpad);
1668
1669   /* srcpad might be flushing already if we're being shut down */
1670   if (outcaps == NULL)
1671     goto no_outcaps;
1672
1673   GST_DEBUG_OBJECT (trans, "getting output size for alloc");
1674   /* copy transform, figure out the output size */
1675   insize = gst_buffer_get_size (inbuf);
1676   res = gst_base_transform_transform_size (trans,
1677       GST_PAD_SINK, incaps, insize, outcaps, &outsize);
1678
1679   gst_caps_unref (incaps);
1680   gst_caps_unref (outcaps);
1681
1682   if (!res)
1683     goto unknown_size;
1684
1685   GST_DEBUG_OBJECT (trans, "doing alloc of size %" G_GSIZE_FORMAT, outsize);
1686   *outbuf = gst_buffer_new_allocate (priv->allocator, outsize, &priv->params);
1687   if (!*outbuf) {
1688     ret = GST_FLOW_ERROR;
1689     goto alloc_failed;
1690   }
1691
1692 copy_meta:
1693   /* copy the metadata */
1694   if (bclass->copy_metadata)
1695     if (!bclass->copy_metadata (trans, inbuf, *outbuf)) {
1696       /* something failed, post a warning */
1697       GST_ELEMENT_WARNING (trans, STREAM, NOT_IMPLEMENTED,
1698           ("could not copy metadata"), (NULL));
1699     }
1700
1701 done:
1702   return GST_FLOW_OK;
1703
1704   /* ERRORS */
1705 activate_failed:
1706   {
1707     GST_ELEMENT_ERROR (trans, RESOURCE, SETTINGS,
1708         ("failed to activate bufferpool"), ("failed to activate bufferpool"));
1709     return GST_FLOW_ERROR;
1710   }
1711 unknown_size:
1712   {
1713     GST_ERROR_OBJECT (trans, "unknown output size");
1714     return GST_FLOW_ERROR;
1715   }
1716 alloc_failed:
1717   {
1718     GST_DEBUG_OBJECT (trans, "could not allocate buffer from pool");
1719     return ret;
1720   }
1721 no_outcaps:
1722   {
1723     GST_DEBUG_OBJECT (trans, "no output caps, source pad has been deactivated");
1724     gst_caps_unref (incaps);
1725     return GST_FLOW_FLUSHING;
1726   }
1727 }
1728
1729 typedef struct
1730 {
1731   GstBaseTransform *trans;
1732   GstBuffer *outbuf;
1733 } CopyMetaData;
1734
1735 static gboolean
1736 foreach_metadata (GstBuffer * inbuf, GstMeta ** meta, gpointer user_data)
1737 {
1738   CopyMetaData *data = user_data;
1739   GstBaseTransform *trans = data->trans;
1740   GstBaseTransformClass *klass;
1741   const GstMetaInfo *info = (*meta)->info;
1742   GstBuffer *outbuf = data->outbuf;
1743   gboolean do_copy = FALSE;
1744
1745   klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1746
1747   if (gst_meta_api_type_has_tag (info->api, _gst_meta_tag_memory)) {
1748     /* never call the transform_meta with memory specific metadata */
1749     GST_DEBUG_OBJECT (trans, "not copying memory specific metadata %s",
1750         g_type_name (info->api));
1751     do_copy = FALSE;
1752   } else if (klass->transform_meta) {
1753     do_copy = klass->transform_meta (trans, outbuf, *meta, inbuf);
1754     GST_DEBUG_OBJECT (trans, "transformed metadata %s: copy: %d",
1755         g_type_name (info->api), do_copy);
1756   }
1757
1758   /* we only copy metadata when the subclass implemented a transform_meta
1759    * function and when it returns %TRUE */
1760   if (do_copy) {
1761     GstMetaTransformCopy copy_data = { FALSE, 0, -1 };
1762     GST_DEBUG_OBJECT (trans, "copy metadata %s", g_type_name (info->api));
1763     /* simply copy then */
1764     info->transform_func (outbuf, *meta, inbuf,
1765         _gst_meta_transform_copy, &copy_data);
1766   }
1767   return TRUE;
1768 }
1769
1770 static gboolean
1771 default_copy_metadata (GstBaseTransform * trans,
1772     GstBuffer * inbuf, GstBuffer * outbuf)
1773 {
1774   GstBaseTransformPrivate *priv = trans->priv;
1775   CopyMetaData data;
1776
1777   /* now copy the metadata */
1778   GST_DEBUG_OBJECT (trans, "copying metadata");
1779
1780   /* this should not happen, buffers allocated from a pool or with
1781    * new_allocate should always be writable. */
1782   if (!gst_buffer_is_writable (outbuf))
1783     goto not_writable;
1784
1785   /* when we get here, the metadata should be writable */
1786   gst_buffer_copy_into (outbuf, inbuf,
1787       GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
1788
1789   /* clear the GAP flag when the subclass does not understand it */
1790   if (!priv->gap_aware)
1791     GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_GAP);
1792
1793
1794   data.trans = trans;
1795   data.outbuf = outbuf;
1796
1797   gst_buffer_foreach_meta (inbuf, foreach_metadata, &data);
1798
1799   return TRUE;
1800
1801   /* ERRORS */
1802 not_writable:
1803   {
1804     GST_WARNING_OBJECT (trans, "buffer %p not writable", outbuf);
1805     return FALSE;
1806   }
1807 }
1808
1809 /* Given @caps calcultate the size of one unit.
1810  *
1811  * For video caps, this is the size of one frame (and thus one buffer).
1812  * For audio caps, this is the size of one sample.
1813  *
1814  * These values are cached since they do not change and the calculation
1815  * potentially involves parsing caps and other expensive stuff.
1816  *
1817  * We have two cache locations to store the size, one for the source caps
1818  * and one for the sink caps.
1819  *
1820  * this function returns %FALSE if no size could be calculated.
1821  */
1822 static gboolean
1823 gst_base_transform_get_unit_size (GstBaseTransform * trans, GstCaps * caps,
1824     gsize * size)
1825 {
1826   gboolean res = FALSE;
1827   GstBaseTransformClass *bclass;
1828   GstBaseTransformPrivate *priv = trans->priv;
1829
1830   /* see if we have the result cached */
1831   if (priv->cache_caps1 == caps) {
1832     *size = priv->cache_caps1_size;
1833     GST_DEBUG_OBJECT (trans,
1834         "returned %" G_GSIZE_FORMAT " from first cache", *size);
1835     return TRUE;
1836   }
1837   if (priv->cache_caps2 == caps) {
1838     *size = priv->cache_caps2_size;
1839     GST_DEBUG_OBJECT (trans,
1840         "returned %" G_GSIZE_FORMAT " from second cached", *size);
1841     return TRUE;
1842   }
1843
1844   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1845   res = bclass->get_unit_size (trans, caps, size);
1846   GST_DEBUG_OBJECT (trans,
1847       "caps %" GST_PTR_FORMAT ") has unit size %" G_GSIZE_FORMAT ", res %s",
1848       caps, *size, res ? "TRUE" : "FALSE");
1849
1850   if (res) {
1851     /* and cache the values */
1852     if (priv->cache_caps1 == NULL) {
1853       gst_caps_replace (&priv->cache_caps1, caps);
1854       priv->cache_caps1_size = *size;
1855       GST_DEBUG_OBJECT (trans,
1856           "caching %" G_GSIZE_FORMAT " in first cache", *size);
1857     } else if (priv->cache_caps2 == NULL) {
1858       gst_caps_replace (&priv->cache_caps2, caps);
1859       priv->cache_caps2_size = *size;
1860       GST_DEBUG_OBJECT (trans,
1861           "caching %" G_GSIZE_FORMAT " in second cache", *size);
1862     } else {
1863       GST_DEBUG_OBJECT (trans, "no free spot to cache unit_size");
1864     }
1865   }
1866   return res;
1867 }
1868
1869 static gboolean
1870 gst_base_transform_sink_event (GstPad * pad, GstObject * parent,
1871     GstEvent * event)
1872 {
1873   GstBaseTransform *trans;
1874   GstBaseTransformClass *bclass;
1875   gboolean ret = TRUE;
1876
1877   trans = GST_BASE_TRANSFORM (parent);
1878   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1879
1880   if (bclass->sink_event)
1881     ret = bclass->sink_event (trans, event);
1882   else
1883     gst_event_unref (event);
1884
1885   return ret;
1886 }
1887
1888 static gboolean
1889 gst_base_transform_sink_eventfunc (GstBaseTransform * trans, GstEvent * event)
1890 {
1891   gboolean ret = TRUE, forward = TRUE;
1892   GstBaseTransformPrivate *priv = trans->priv;
1893
1894   switch (GST_EVENT_TYPE (event)) {
1895     case GST_EVENT_FLUSH_START:
1896       break;
1897     case GST_EVENT_FLUSH_STOP:
1898       GST_OBJECT_LOCK (trans);
1899       /* reset QoS parameters */
1900       priv->proportion = 1.0;
1901       priv->earliest_time = -1;
1902       priv->discont = FALSE;
1903       priv->processed = 0;
1904       priv->dropped = 0;
1905       GST_OBJECT_UNLOCK (trans);
1906       /* we need new segment info after the flush. */
1907       trans->have_segment = FALSE;
1908       gst_segment_init (&trans->segment, GST_FORMAT_UNDEFINED);
1909       priv->position_out = GST_CLOCK_TIME_NONE;
1910       break;
1911     case GST_EVENT_EOS:
1912       break;
1913     case GST_EVENT_TAG:
1914       break;
1915     case GST_EVENT_CAPS:
1916     {
1917       GstCaps *caps;
1918
1919       gst_event_parse_caps (event, &caps);
1920       /* clear any pending reconfigure flag */
1921       gst_pad_check_reconfigure (trans->srcpad);
1922       ret = gst_base_transform_setcaps (trans, trans->sinkpad, caps);
1923
1924       forward = FALSE;
1925       break;
1926     }
1927     case GST_EVENT_SEGMENT:
1928     {
1929       gst_event_copy_segment (event, &trans->segment);
1930       trans->have_segment = TRUE;
1931
1932       GST_DEBUG_OBJECT (trans, "received SEGMENT %" GST_SEGMENT_FORMAT,
1933           &trans->segment);
1934       break;
1935     }
1936     default:
1937       break;
1938   }
1939
1940   if (ret && forward)
1941     ret = gst_pad_push_event (trans->srcpad, event);
1942   else
1943     gst_event_unref (event);
1944
1945   return ret;
1946 }
1947
1948 static gboolean
1949 gst_base_transform_src_event (GstPad * pad, GstObject * parent,
1950     GstEvent * event)
1951 {
1952   GstBaseTransform *trans;
1953   GstBaseTransformClass *bclass;
1954   gboolean ret = TRUE;
1955
1956   trans = GST_BASE_TRANSFORM (parent);
1957   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
1958
1959   if (bclass->src_event)
1960     ret = bclass->src_event (trans, event);
1961   else
1962     gst_event_unref (event);
1963
1964   return ret;
1965 }
1966
1967 static gboolean
1968 gst_base_transform_src_eventfunc (GstBaseTransform * trans, GstEvent * event)
1969 {
1970   gboolean ret;
1971
1972   GST_DEBUG_OBJECT (trans, "handling event %p %" GST_PTR_FORMAT, event, event);
1973
1974   switch (GST_EVENT_TYPE (event)) {
1975     case GST_EVENT_SEEK:
1976       break;
1977     case GST_EVENT_NAVIGATION:
1978       break;
1979     case GST_EVENT_QOS:
1980     {
1981       gdouble proportion;
1982       GstClockTimeDiff diff;
1983       GstClockTime timestamp;
1984
1985       gst_event_parse_qos (event, NULL, &proportion, &diff, &timestamp);
1986       gst_base_transform_update_qos (trans, proportion, diff, timestamp);
1987       break;
1988     }
1989     default:
1990       break;
1991   }
1992
1993   ret = gst_pad_push_event (trans->sinkpad, event);
1994
1995   return ret;
1996 }
1997
1998 /* Takes the input buffer */
1999 static GstFlowReturn
2000 default_submit_input_buffer (GstBaseTransform * trans, gboolean is_discont,
2001     GstBuffer * inbuf)
2002 {
2003   GstBaseTransformClass *bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2004   GstBaseTransformPrivate *priv = trans->priv;
2005   GstFlowReturn ret = GST_FLOW_OK;
2006   gboolean reconfigure;
2007   GstClockTime running_time;
2008   GstClockTime timestamp;
2009
2010   reconfigure = gst_pad_check_reconfigure (trans->srcpad);
2011
2012   if (G_UNLIKELY (reconfigure)) {
2013     GstCaps *incaps;
2014
2015     GST_DEBUG_OBJECT (trans, "we had a pending reconfigure");
2016
2017     incaps = gst_pad_get_current_caps (trans->sinkpad);
2018     if (incaps == NULL)
2019       goto no_reconfigure;
2020
2021     /* if we need to reconfigure we pretend new caps arrived. This
2022      * will reconfigure the transform with the new output format. */
2023     if (!gst_base_transform_setcaps (trans, trans->sinkpad, incaps)) {
2024       gst_caps_unref (incaps);
2025       goto not_negotiated;
2026     }
2027     gst_caps_unref (incaps);
2028   }
2029
2030 no_reconfigure:
2031   if (GST_BUFFER_OFFSET_IS_VALID (inbuf))
2032     GST_DEBUG_OBJECT (trans,
2033         "handling buffer %p of size %" G_GSIZE_FORMAT " and offset %"
2034         G_GUINT64_FORMAT, inbuf, gst_buffer_get_size (inbuf),
2035         GST_BUFFER_OFFSET (inbuf));
2036   else
2037     GST_DEBUG_OBJECT (trans,
2038         "handling buffer %p of size %" G_GSIZE_FORMAT " and offset NONE", inbuf,
2039         gst_buffer_get_size (inbuf));
2040
2041   /* Don't allow buffer handling before negotiation, except in passthrough mode
2042    * or if the class doesn't implement a set_caps function (in which case it doesn't
2043    * care about caps)
2044    */
2045   if (!priv->negotiated && !priv->passthrough && (bclass->set_caps != NULL))
2046     goto not_negotiated;
2047
2048   /* can only do QoS if the segment is in TIME */
2049   if (trans->segment.format != GST_FORMAT_TIME)
2050     goto no_qos;
2051
2052   /* QOS is done on the running time of the buffer, get it now */
2053   timestamp = GST_BUFFER_TIMESTAMP (inbuf);
2054   running_time = gst_segment_to_running_time (&trans->segment, GST_FORMAT_TIME,
2055       timestamp);
2056
2057   if (running_time != -1) {
2058     gboolean need_skip;
2059     GstClockTime earliest_time;
2060     gdouble proportion;
2061
2062     /* lock for getting the QoS parameters that are set (in a different thread)
2063      * with the QOS events */
2064     GST_OBJECT_LOCK (trans);
2065     earliest_time = priv->earliest_time;
2066     proportion = priv->proportion;
2067     /* check for QoS, don't perform conversion for buffers
2068      * that are known to be late. */
2069     need_skip = priv->qos_enabled &&
2070         earliest_time != -1 && running_time <= earliest_time;
2071     GST_OBJECT_UNLOCK (trans);
2072
2073     if (need_skip) {
2074       GstMessage *qos_msg;
2075       GstClockTime duration;
2076       guint64 stream_time;
2077       gint64 jitter;
2078
2079       GST_CAT_DEBUG_OBJECT (GST_CAT_QOS, trans, "skipping transform: qostime %"
2080           GST_TIME_FORMAT " <= %" GST_TIME_FORMAT,
2081           GST_TIME_ARGS (running_time), GST_TIME_ARGS (earliest_time));
2082
2083       priv->dropped++;
2084
2085       duration = GST_BUFFER_DURATION (inbuf);
2086       stream_time =
2087           gst_segment_to_stream_time (&trans->segment, GST_FORMAT_TIME,
2088           timestamp);
2089       jitter = GST_CLOCK_DIFF (running_time, earliest_time);
2090
2091       qos_msg =
2092           gst_message_new_qos (GST_OBJECT_CAST (trans), FALSE, running_time,
2093           stream_time, timestamp, duration);
2094       gst_message_set_qos_values (qos_msg, jitter, proportion, 1000000);
2095       gst_message_set_qos_stats (qos_msg, GST_FORMAT_BUFFERS,
2096           priv->processed, priv->dropped);
2097       gst_element_post_message (GST_ELEMENT_CAST (trans), qos_msg);
2098
2099       /* mark discont for next buffer */
2100       priv->discont = TRUE;
2101       ret = GST_BASE_TRANSFORM_FLOW_DROPPED;
2102       goto skip;
2103     }
2104   }
2105
2106 no_qos:
2107   /* Stash input buffer where the default generate_output
2108    * function can find it */
2109   if (trans->queued_buf)
2110     gst_buffer_unref (trans->queued_buf);
2111   trans->queued_buf = inbuf;
2112   return ret;
2113 skip:
2114   gst_buffer_unref (inbuf);
2115   return ret;
2116
2117 not_negotiated:
2118   {
2119     gst_buffer_unref (inbuf);
2120     if (GST_PAD_IS_FLUSHING (trans->srcpad))
2121       return GST_FLOW_FLUSHING;
2122     GST_ELEMENT_WARNING (trans, STREAM, FORMAT,
2123         ("not negotiated"), ("not negotiated"));
2124     return GST_FLOW_NOT_NEGOTIATED;
2125   }
2126 }
2127
2128 static GstFlowReturn
2129 default_generate_output (GstBaseTransform * trans, GstBuffer ** outbuf)
2130 {
2131   GstBaseTransformClass *bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2132   GstBaseTransformPrivate *priv = trans->priv;
2133   GstFlowReturn ret = GST_FLOW_OK;
2134   GstBuffer *inbuf;
2135   gboolean want_in_place;
2136
2137   /* Retrieve stashed input buffer, if the default submit_input_buffer
2138    * was run. Takes ownership back from there */
2139   inbuf = trans->queued_buf;
2140   trans->queued_buf = NULL;
2141
2142   /* This default processing method needs one input buffer to feed to
2143    * the transform functions, we can't do anything without it */
2144   if (inbuf == NULL)
2145     return GST_FLOW_OK;
2146
2147   /* first try to allocate an output buffer based on the currently negotiated
2148    * format. outbuf will contain a buffer suitable for doing the configured
2149    * transform after this function. */
2150   if (bclass->prepare_output_buffer == NULL)
2151     goto no_prepare;
2152
2153   GST_DEBUG_OBJECT (trans, "calling prepare buffer");
2154   ret = bclass->prepare_output_buffer (trans, inbuf, outbuf);
2155
2156   if (ret != GST_FLOW_OK || *outbuf == NULL)
2157     goto no_buffer;
2158
2159   GST_DEBUG_OBJECT (trans, "using allocated buffer in %p, out %p", inbuf,
2160       *outbuf);
2161
2162   /* now perform the needed transform */
2163   if (priv->passthrough) {
2164     /* In passthrough mode, give transform_ip a look at the
2165      * buffer, without making it writable, or just push the
2166      * data through */
2167     if (bclass->transform_ip_on_passthrough && bclass->transform_ip) {
2168       GST_DEBUG_OBJECT (trans, "doing passthrough transform_ip");
2169       ret = bclass->transform_ip (trans, *outbuf);
2170     } else {
2171       GST_DEBUG_OBJECT (trans, "element is in passthrough");
2172     }
2173   } else {
2174     want_in_place = (bclass->transform_ip != NULL) && priv->always_in_place;
2175
2176     if (want_in_place) {
2177       GST_DEBUG_OBJECT (trans, "doing inplace transform");
2178       ret = bclass->transform_ip (trans, *outbuf);
2179     } else {
2180       GST_DEBUG_OBJECT (trans, "doing non-inplace transform");
2181
2182       if (bclass->transform)
2183         ret = bclass->transform (trans, inbuf, *outbuf);
2184       else
2185         ret = GST_FLOW_NOT_SUPPORTED;
2186     }
2187   }
2188
2189   /* only unref input buffer if we allocated a new outbuf buffer. If we reused
2190    * the input buffer, no refcount is changed to keep the input buffer writable
2191    * when needed. */
2192   if (*outbuf != inbuf)
2193     gst_buffer_unref (inbuf);
2194
2195   return ret;
2196
2197   /* ERRORS */
2198 no_prepare:
2199   {
2200     gst_buffer_unref (inbuf);
2201     GST_ELEMENT_ERROR (trans, STREAM, NOT_IMPLEMENTED,
2202         ("Sub-class has no prepare_output_buffer implementation"), (NULL));
2203     return GST_FLOW_NOT_SUPPORTED;
2204   }
2205 no_buffer:
2206   {
2207     gst_buffer_unref (inbuf);
2208     *outbuf = NULL;
2209     GST_WARNING_OBJECT (trans, "could not get buffer from pool: %s",
2210         gst_flow_get_name (ret));
2211     return ret;
2212   }
2213 }
2214
2215 /* FIXME, getrange is broken, need to pull range from the other
2216  * end based on the transform_size result.
2217  */
2218 static GstFlowReturn
2219 gst_base_transform_getrange (GstPad * pad, GstObject * parent, guint64 offset,
2220     guint length, GstBuffer ** buffer)
2221 {
2222   GstBaseTransformClass *klass = GST_BASE_TRANSFORM_GET_CLASS (parent);
2223   GstBaseTransform *trans = GST_BASE_TRANSFORM (parent);
2224   GstBaseTransformPrivate *priv = trans->priv;
2225   GstFlowReturn ret;
2226   GstBuffer *inbuf = NULL;
2227   GstBuffer *outbuf = NULL;
2228
2229   /* Try and generate a buffer, if the sub-class wants more data,
2230    * pull some and repeat until a buffer (or error) is produced */
2231   do {
2232     ret = klass->generate_output (trans, &outbuf);
2233
2234     /* Consume the DROPPED return value and go get more data */
2235     if (ret == GST_BASE_TRANSFORM_FLOW_DROPPED)
2236       ret = GST_FLOW_OK;
2237
2238     if (ret != GST_FLOW_OK || outbuf != NULL)
2239       break;
2240
2241     /* No buffer generated, try and pull data */
2242     ret = gst_pad_pull_range (trans->sinkpad, offset, length, &inbuf);
2243     if (G_UNLIKELY (ret != GST_FLOW_OK))
2244       goto pull_error;
2245
2246     if (klass->before_transform)
2247       klass->before_transform (trans, inbuf);
2248
2249     /* Set discont flag so we can mark the next outgoing buffer */
2250     if (GST_BUFFER_IS_DISCONT (inbuf)) {
2251       GST_DEBUG_OBJECT (trans, "got DISCONT buffer %p", inbuf);
2252       priv->discont = TRUE;
2253     }
2254
2255     /* FIXME: Input offsets and lengths need to be translated, as per
2256      * the FIXME above. For now, just advance somewhat */
2257     offset += gst_buffer_get_size (inbuf);
2258
2259     ret = klass->submit_input_buffer (trans, priv->discont, inbuf);
2260     if (ret != GST_FLOW_OK) {
2261       if (ret == GST_BASE_TRANSFORM_FLOW_DROPPED)
2262         ret = GST_FLOW_OK;
2263       goto done;
2264     }
2265   } while (ret == GST_FLOW_OK && outbuf == NULL);
2266
2267   *buffer = outbuf;
2268   if (outbuf) {
2269     /* apply DISCONT flag if the buffer is not yet marked as such */
2270     if (priv->discont) {
2271       GST_DEBUG_OBJECT (trans, "we have a pending DISCONT");
2272       if (!GST_BUFFER_IS_DISCONT (outbuf)) {
2273         GST_DEBUG_OBJECT (trans, "marking DISCONT on output buffer");
2274         outbuf = gst_buffer_make_writable (outbuf);
2275         GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
2276       }
2277       priv->discont = FALSE;
2278     }
2279     priv->processed++;
2280   }
2281 done:
2282   return ret;
2283
2284   /* ERRORS */
2285 pull_error:
2286   {
2287     GST_DEBUG_OBJECT (trans, "failed to pull a buffer: %s",
2288         gst_flow_get_name (ret));
2289     goto done;
2290   }
2291 }
2292
2293 /* The flow of the chain function is the reverse of the
2294  * getrange() function - we have data, feed it to the sub-class
2295  * and then iterate, pushing buffers it generates until it either
2296  * wants more data or returns an error */
2297 static GstFlowReturn
2298 gst_base_transform_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
2299 {
2300   GstBaseTransform *trans = GST_BASE_TRANSFORM (parent);
2301   GstBaseTransformClass *klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2302   GstBaseTransformPrivate *priv = trans->priv;
2303   GstFlowReturn ret;
2304   GstClockTime position = GST_CLOCK_TIME_NONE;
2305   GstClockTime timestamp, duration;
2306   GstBuffer *outbuf = NULL;
2307
2308   timestamp = GST_BUFFER_TIMESTAMP (buffer);
2309   duration = GST_BUFFER_DURATION (buffer);
2310
2311   /* calculate end position of the incoming buffer */
2312   if (timestamp != GST_CLOCK_TIME_NONE) {
2313     if (duration != GST_CLOCK_TIME_NONE)
2314       position = timestamp + duration;
2315     else
2316       position = timestamp;
2317   }
2318
2319   if (klass->before_transform)
2320     klass->before_transform (trans, buffer);
2321
2322   /* Set discont flag so we can mark the outgoing buffer */
2323   if (GST_BUFFER_IS_DISCONT (buffer)) {
2324     GST_DEBUG_OBJECT (trans, "got DISCONT buffer %p", buffer);
2325     priv->discont = TRUE;
2326   }
2327
2328   /* Takes ownership of input buffer */
2329   ret = klass->submit_input_buffer (trans, priv->discont, buffer);
2330   if (ret != GST_FLOW_OK)
2331     goto done;
2332
2333   do {
2334     outbuf = NULL;
2335
2336     ret = klass->generate_output (trans, &outbuf);
2337
2338     /* outbuf can be NULL, this means a dropped buffer, if we have a buffer but
2339      * GST_BASE_TRANSFORM_FLOW_DROPPED we will not push either. */
2340     if (outbuf != NULL) {
2341       if (ret == GST_FLOW_OK) {
2342         GstClockTime position_out = GST_CLOCK_TIME_NONE;
2343
2344         /* Remember last stop position */
2345         if (position != GST_CLOCK_TIME_NONE &&
2346             trans->segment.format == GST_FORMAT_TIME)
2347           trans->segment.position = position;
2348
2349         if (GST_BUFFER_TIMESTAMP_IS_VALID (outbuf)) {
2350           position_out = GST_BUFFER_TIMESTAMP (outbuf);
2351           if (GST_BUFFER_DURATION_IS_VALID (outbuf))
2352             position_out += GST_BUFFER_DURATION (outbuf);
2353         } else if (position != GST_CLOCK_TIME_NONE) {
2354           position_out = position;
2355         }
2356         if (position_out != GST_CLOCK_TIME_NONE
2357             && trans->segment.format == GST_FORMAT_TIME)
2358           priv->position_out = position_out;
2359
2360         /* apply DISCONT flag if the buffer is not yet marked as such */
2361         if (trans->priv->discont) {
2362           GST_DEBUG_OBJECT (trans, "we have a pending DISCONT");
2363           if (!GST_BUFFER_IS_DISCONT (outbuf)) {
2364             GST_DEBUG_OBJECT (trans, "marking DISCONT on output buffer");
2365             outbuf = gst_buffer_make_writable (outbuf);
2366             GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
2367           }
2368           priv->discont = FALSE;
2369         }
2370         priv->processed++;
2371
2372         ret = gst_pad_push (trans->srcpad, outbuf);
2373       } else {
2374         GST_DEBUG_OBJECT (trans, "we got return %s", gst_flow_get_name (ret));
2375         gst_buffer_unref (outbuf);
2376       }
2377     }
2378   } while (ret == GST_FLOW_OK && outbuf != NULL);
2379
2380 done:
2381   /* convert internal flow to OK and mark discont for the next buffer. */
2382   if (ret == GST_BASE_TRANSFORM_FLOW_DROPPED) {
2383     GST_DEBUG_OBJECT (trans, "dropped a buffer, marking DISCONT");
2384     priv->discont = TRUE;
2385     ret = GST_FLOW_OK;
2386   }
2387
2388   return ret;
2389 }
2390
2391 static void
2392 gst_base_transform_set_property (GObject * object, guint prop_id,
2393     const GValue * value, GParamSpec * pspec)
2394 {
2395   GstBaseTransform *trans;
2396
2397   trans = GST_BASE_TRANSFORM (object);
2398
2399   switch (prop_id) {
2400     case PROP_QOS:
2401       gst_base_transform_set_qos_enabled (trans, g_value_get_boolean (value));
2402       break;
2403     default:
2404       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2405       break;
2406   }
2407 }
2408
2409 static void
2410 gst_base_transform_get_property (GObject * object, guint prop_id,
2411     GValue * value, GParamSpec * pspec)
2412 {
2413   GstBaseTransform *trans;
2414
2415   trans = GST_BASE_TRANSFORM (object);
2416
2417   switch (prop_id) {
2418     case PROP_QOS:
2419       g_value_set_boolean (value, gst_base_transform_is_qos_enabled (trans));
2420       break;
2421     default:
2422       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2423       break;
2424   }
2425 }
2426
2427 /* not a vmethod of anything, just an internal method */
2428 static gboolean
2429 gst_base_transform_activate (GstBaseTransform * trans, gboolean active)
2430 {
2431   GstBaseTransformClass *bclass;
2432   GstBaseTransformPrivate *priv = trans->priv;
2433   gboolean result = TRUE;
2434
2435   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2436
2437   if (active) {
2438     GstCaps *incaps, *outcaps;
2439
2440     if (priv->pad_mode == GST_PAD_MODE_NONE && bclass->start)
2441       result &= bclass->start (trans);
2442
2443     incaps = gst_pad_get_current_caps (trans->sinkpad);
2444     outcaps = gst_pad_get_current_caps (trans->srcpad);
2445
2446     GST_OBJECT_LOCK (trans);
2447     if (incaps && outcaps)
2448       priv->have_same_caps =
2449           gst_caps_is_equal (incaps, outcaps) || priv->passthrough;
2450     else
2451       priv->have_same_caps = priv->passthrough;
2452     GST_DEBUG_OBJECT (trans, "have_same_caps %d", priv->have_same_caps);
2453     priv->negotiated = FALSE;
2454     trans->have_segment = FALSE;
2455     gst_segment_init (&trans->segment, GST_FORMAT_UNDEFINED);
2456     priv->position_out = GST_CLOCK_TIME_NONE;
2457     priv->proportion = 1.0;
2458     priv->earliest_time = -1;
2459     priv->discont = FALSE;
2460     priv->processed = 0;
2461     priv->dropped = 0;
2462     GST_OBJECT_UNLOCK (trans);
2463
2464     if (incaps)
2465       gst_caps_unref (incaps);
2466     if (outcaps)
2467       gst_caps_unref (outcaps);
2468   } else {
2469     /* We must make sure streaming has finished before resetting things
2470      * and calling the ::stop vfunc */
2471     GST_PAD_STREAM_LOCK (trans->sinkpad);
2472     GST_PAD_STREAM_UNLOCK (trans->sinkpad);
2473
2474     priv->have_same_caps = FALSE;
2475     /* We can only reset the passthrough mode if the instance told us to
2476        handle it in configure_caps */
2477     if (bclass->passthrough_on_same_caps) {
2478       gst_base_transform_set_passthrough (trans, FALSE);
2479     }
2480     gst_caps_replace (&priv->cache_caps1, NULL);
2481     gst_caps_replace (&priv->cache_caps2, NULL);
2482
2483     /* Make sure any left over buffer is freed */
2484     gst_buffer_replace (&trans->queued_buf, NULL);
2485
2486     if (priv->pad_mode != GST_PAD_MODE_NONE && bclass->stop)
2487       result &= bclass->stop (trans);
2488
2489     gst_base_transform_set_allocation (trans, NULL, NULL, NULL, NULL);
2490   }
2491
2492   return result;
2493 }
2494
2495 static gboolean
2496 gst_base_transform_sink_activate_mode (GstPad * pad, GstObject * parent,
2497     GstPadMode mode, gboolean active)
2498 {
2499   gboolean result = FALSE;
2500   GstBaseTransform *trans;
2501
2502   trans = GST_BASE_TRANSFORM (parent);
2503
2504   switch (mode) {
2505     case GST_PAD_MODE_PUSH:
2506     {
2507       result = gst_base_transform_activate (trans, active);
2508
2509       if (result)
2510         trans->priv->pad_mode = active ? GST_PAD_MODE_PUSH : GST_PAD_MODE_NONE;
2511
2512       break;
2513     }
2514     default:
2515       result = TRUE;
2516       break;
2517   }
2518   return result;
2519 }
2520
2521 static gboolean
2522 gst_base_transform_src_activate_mode (GstPad * pad, GstObject * parent,
2523     GstPadMode mode, gboolean active)
2524 {
2525   gboolean result = FALSE;
2526   GstBaseTransform *trans;
2527
2528   trans = GST_BASE_TRANSFORM (parent);
2529
2530   switch (mode) {
2531     case GST_PAD_MODE_PULL:
2532     {
2533       result =
2534           gst_pad_activate_mode (trans->sinkpad, GST_PAD_MODE_PULL, active);
2535
2536       if (result)
2537         result &= gst_base_transform_activate (trans, active);
2538
2539       if (result)
2540         trans->priv->pad_mode = active ? mode : GST_PAD_MODE_NONE;
2541       break;
2542     }
2543     default:
2544       result = TRUE;
2545       break;
2546   }
2547
2548   return result;
2549 }
2550
2551 /**
2552  * gst_base_transform_set_passthrough:
2553  * @trans: the #GstBaseTransform to set
2554  * @passthrough: boolean indicating passthrough mode.
2555  *
2556  * Set passthrough mode for this filter by default. This is mostly
2557  * useful for filters that do not care about negotiation.
2558  *
2559  * Always %TRUE for filters which don't implement either a transform
2560  * or transform_ip method.
2561  *
2562  * MT safe.
2563  */
2564 void
2565 gst_base_transform_set_passthrough (GstBaseTransform * trans,
2566     gboolean passthrough)
2567 {
2568   GstBaseTransformClass *bclass;
2569
2570   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2571
2572   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2573
2574   GST_OBJECT_LOCK (trans);
2575   if (!passthrough) {
2576     if (bclass->transform_ip || bclass->transform)
2577       trans->priv->passthrough = FALSE;
2578   } else {
2579     trans->priv->passthrough = TRUE;
2580   }
2581
2582   GST_DEBUG_OBJECT (trans, "set passthrough %d", trans->priv->passthrough);
2583   GST_OBJECT_UNLOCK (trans);
2584 }
2585
2586 /**
2587  * gst_base_transform_is_passthrough:
2588  * @trans: the #GstBaseTransform to query
2589  *
2590  * See if @trans is configured as a passthrough transform.
2591  *
2592  * Returns: %TRUE is the transform is configured in passthrough mode.
2593  *
2594  * MT safe.
2595  */
2596 gboolean
2597 gst_base_transform_is_passthrough (GstBaseTransform * trans)
2598 {
2599   gboolean result;
2600
2601   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), FALSE);
2602
2603   GST_OBJECT_LOCK (trans);
2604   result = trans->priv->passthrough;
2605   GST_OBJECT_UNLOCK (trans);
2606
2607   return result;
2608 }
2609
2610 /**
2611  * gst_base_transform_set_in_place:
2612  * @trans: the #GstBaseTransform to modify
2613  * @in_place: Boolean value indicating that we would like to operate
2614  * on in_place buffers.
2615  *
2616  * Determines whether a non-writable buffer will be copied before passing
2617  * to the transform_ip function.
2618  * <itemizedlist>
2619  *   <listitem>Always %TRUE if no transform function is implemented.</listitem>
2620  *   <listitem>Always %FALSE if ONLY transform function is implemented.</listitem>
2621  * </itemizedlist>
2622  *
2623  * MT safe.
2624  */
2625 void
2626 gst_base_transform_set_in_place (GstBaseTransform * trans, gboolean in_place)
2627 {
2628   GstBaseTransformClass *bclass;
2629
2630   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2631
2632   bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
2633
2634   GST_OBJECT_LOCK (trans);
2635
2636   if (in_place) {
2637     if (bclass->transform_ip) {
2638       GST_DEBUG_OBJECT (trans, "setting in_place TRUE");
2639       trans->priv->always_in_place = TRUE;
2640     }
2641   } else {
2642     if (bclass->transform) {
2643       GST_DEBUG_OBJECT (trans, "setting in_place FALSE");
2644       trans->priv->always_in_place = FALSE;
2645     }
2646   }
2647
2648   GST_OBJECT_UNLOCK (trans);
2649 }
2650
2651 /**
2652  * gst_base_transform_is_in_place:
2653  * @trans: the #GstBaseTransform to query
2654  *
2655  * See if @trans is configured as a in_place transform.
2656  *
2657  * Returns: %TRUE is the transform is configured in in_place mode.
2658  *
2659  * MT safe.
2660  */
2661 gboolean
2662 gst_base_transform_is_in_place (GstBaseTransform * trans)
2663 {
2664   gboolean result;
2665
2666   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), FALSE);
2667
2668   GST_OBJECT_LOCK (trans);
2669   result = trans->priv->always_in_place;
2670   GST_OBJECT_UNLOCK (trans);
2671
2672   return result;
2673 }
2674
2675 /**
2676  * gst_base_transform_update_qos:
2677  * @trans: a #GstBaseTransform
2678  * @proportion: the proportion
2679  * @diff: the diff against the clock
2680  * @timestamp: the timestamp of the buffer generating the QoS expressed in
2681  * running_time.
2682  *
2683  * Set the QoS parameters in the transform. This function is called internally
2684  * when a QOS event is received but subclasses can provide custom information
2685  * when needed.
2686  *
2687  * MT safe.
2688  */
2689 void
2690 gst_base_transform_update_qos (GstBaseTransform * trans,
2691     gdouble proportion, GstClockTimeDiff diff, GstClockTime timestamp)
2692 {
2693   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2694
2695   GST_CAT_DEBUG_OBJECT (GST_CAT_QOS, trans,
2696       "qos: proportion: %lf, diff %" G_GINT64_FORMAT ", timestamp %"
2697       GST_TIME_FORMAT, proportion, diff, GST_TIME_ARGS (timestamp));
2698
2699   GST_OBJECT_LOCK (trans);
2700   trans->priv->proportion = proportion;
2701   trans->priv->earliest_time = timestamp + diff;
2702   GST_OBJECT_UNLOCK (trans);
2703 }
2704
2705 /**
2706  * gst_base_transform_set_qos_enabled:
2707  * @trans: a #GstBaseTransform
2708  * @enabled: new state
2709  *
2710  * Enable or disable QoS handling in the transform.
2711  *
2712  * MT safe.
2713  */
2714 void
2715 gst_base_transform_set_qos_enabled (GstBaseTransform * trans, gboolean enabled)
2716 {
2717   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2718
2719   GST_CAT_DEBUG_OBJECT (GST_CAT_QOS, trans, "enabled: %d", enabled);
2720
2721   GST_OBJECT_LOCK (trans);
2722   trans->priv->qos_enabled = enabled;
2723   GST_OBJECT_UNLOCK (trans);
2724 }
2725
2726 /**
2727  * gst_base_transform_is_qos_enabled:
2728  * @trans: a #GstBaseTransform
2729  *
2730  * Queries if the transform will handle QoS.
2731  *
2732  * Returns: %TRUE if QoS is enabled.
2733  *
2734  * MT safe.
2735  */
2736 gboolean
2737 gst_base_transform_is_qos_enabled (GstBaseTransform * trans)
2738 {
2739   gboolean result;
2740
2741   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), FALSE);
2742
2743   GST_OBJECT_LOCK (trans);
2744   result = trans->priv->qos_enabled;
2745   GST_OBJECT_UNLOCK (trans);
2746
2747   return result;
2748 }
2749
2750 /**
2751  * gst_base_transform_set_gap_aware:
2752  * @trans: a #GstBaseTransform
2753  * @gap_aware: New state
2754  *
2755  * If @gap_aware is %FALSE (the default), output buffers will have the
2756  * %GST_BUFFER_FLAG_GAP flag unset.
2757  *
2758  * If set to %TRUE, the element must handle output buffers with this flag set
2759  * correctly, i.e. it can assume that the buffer contains neutral data but must
2760  * unset the flag if the output is no neutral data.
2761  *
2762  * MT safe.
2763  */
2764 void
2765 gst_base_transform_set_gap_aware (GstBaseTransform * trans, gboolean gap_aware)
2766 {
2767   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2768
2769   GST_OBJECT_LOCK (trans);
2770   trans->priv->gap_aware = gap_aware;
2771   GST_DEBUG_OBJECT (trans, "set gap aware %d", trans->priv->gap_aware);
2772   GST_OBJECT_UNLOCK (trans);
2773 }
2774
2775 /**
2776  * gst_base_transform_set_prefer_passthrough:
2777  * @trans: a #GstBaseTransform
2778  * @prefer_passthrough: New state
2779  *
2780  * If @prefer_passthrough is %TRUE (the default), @trans will check and
2781  * prefer passthrough caps from the list of caps returned by the
2782  * transform_caps vmethod.
2783  *
2784  * If set to %FALSE, the element must order the caps returned from the
2785  * transform_caps function in such a way that the preferred format is
2786  * first in the list. This can be interesting for transforms that can do
2787  * passthrough transforms but prefer to do something else, like a
2788  * capsfilter.
2789  *
2790  * MT safe.
2791  *
2792  * Since: 1.0.1
2793  */
2794 void
2795 gst_base_transform_set_prefer_passthrough (GstBaseTransform * trans,
2796     gboolean prefer_passthrough)
2797 {
2798   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2799
2800   GST_OBJECT_LOCK (trans);
2801   trans->priv->prefer_passthrough = prefer_passthrough;
2802   GST_DEBUG_OBJECT (trans, "prefer passthrough %d", prefer_passthrough);
2803   GST_OBJECT_UNLOCK (trans);
2804 }
2805
2806 /**
2807  * gst_base_transform_reconfigure_sink:
2808  * @trans: a #GstBaseTransform
2809  *
2810  * Instructs @trans to request renegotiation upstream. This function is
2811  * typically called after properties on the transform were set that
2812  * influence the input format.
2813  */
2814 void
2815 gst_base_transform_reconfigure_sink (GstBaseTransform * trans)
2816 {
2817   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2818
2819   /* push the renegotiate event */
2820   if (!gst_pad_push_event (GST_BASE_TRANSFORM_SINK_PAD (trans),
2821           gst_event_new_reconfigure ()))
2822     GST_DEBUG_OBJECT (trans, "Renegotiate event wasn't handled");
2823 }
2824
2825 /**
2826  * gst_base_transform_reconfigure_src:
2827  * @trans: a #GstBaseTransform
2828  *
2829  * Instructs @trans to renegotiate a new downstream transform on the next
2830  * buffer. This function is typically called after properties on the transform
2831  * were set that influence the output format.
2832  */
2833 void
2834 gst_base_transform_reconfigure_src (GstBaseTransform * trans)
2835 {
2836   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2837
2838   gst_pad_mark_reconfigure (trans->srcpad);
2839 }
2840
2841 /**
2842  * gst_base_transform_get_buffer_pool:
2843  * @trans: a #GstBaseTransform
2844  *
2845  * Returns: (transfer full): the instance of the #GstBufferPool used
2846  * by @trans; free it after use it
2847  */
2848 GstBufferPool *
2849 gst_base_transform_get_buffer_pool (GstBaseTransform * trans)
2850 {
2851   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), NULL);
2852
2853   if (trans->priv->pool)
2854     return gst_object_ref (trans->priv->pool);
2855
2856   return NULL;
2857 }
2858
2859 /**
2860  * gst_base_transform_get_allocator:
2861  * @trans: a #GstBaseTransform
2862  * @allocator: (out) (allow-none) (transfer full): the #GstAllocator
2863  * used
2864  * @params: (out) (allow-none) (transfer full): the
2865  * #GstAllocationParams of @allocator
2866  *
2867  * Lets #GstBaseTransform sub-classes to know the memory @allocator
2868  * used by the base class and its @params.
2869  *
2870  * Unref the @allocator after use it.
2871  */
2872 void
2873 gst_base_transform_get_allocator (GstBaseTransform * trans,
2874     GstAllocator ** allocator, GstAllocationParams * params)
2875 {
2876   g_return_if_fail (GST_IS_BASE_TRANSFORM (trans));
2877
2878   if (allocator)
2879     *allocator = trans->priv->allocator ?
2880         gst_object_ref (trans->priv->allocator) : NULL;
2881
2882   if (params)
2883     *params = trans->priv->params;
2884 }
2885
2886 /**
2887  * gst_base_transform_update_src_caps:
2888  * @trans: a #GstBaseTransform
2889  * @updated_caps: An updated version of the srcpad caps to be pushed
2890  * downstream
2891  *
2892  * Updates the srcpad caps and send the caps downstream. This function
2893  * can be used by subclasses when they have already negotiated their caps
2894  * but found a change in them (or computed new informations). This way,
2895  * they can notify downstream about that change without loosing any
2896  * buffer.
2897  *
2898  * Returns: %TRUE if the caps could be send downstream %FALSE otherwise
2899  *
2900  * Since: 1.6
2901  */
2902 gboolean
2903 gst_base_transform_update_src_caps (GstBaseTransform * trans,
2904     GstCaps * updated_caps)
2905 {
2906   g_return_val_if_fail (GST_IS_BASE_TRANSFORM (trans), FALSE);
2907
2908   if (gst_pad_push_event (GST_BASE_TRANSFORM_SRC_PAD (trans),
2909           gst_event_new_caps (updated_caps))) {
2910     gst_pad_mark_reconfigure (trans->srcpad);
2911
2912     return TRUE;
2913   }
2914
2915   return FALSE;
2916 }