LCOV - code coverage report
Current view: top level - libs/gst/base - gstcollectpads.c (source / functions) Hit Total Coverage
Test: GStreamer 0.10.32.1 Lines: 0 492 0.0 %
Date: 2011-03-25 Functions: 0 36 0.0 %
Branches: 0 651 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* GStreamer
       2                 :            :  * Copyright (C) 2005 Wim Taymans <wim@fluendo.com>
       3                 :            :  *
       4                 :            :  * gstcollectpads.c:
       5                 :            :  *
       6                 :            :  * This library is free software; you can redistribute it and/or
       7                 :            :  * modify it under the terms of the GNU Library General Public
       8                 :            :  * License as published by the Free Software Foundation; either
       9                 :            :  * version 2 of the License, or (at your option) any later version.
      10                 :            :  *
      11                 :            :  * This library is distributed in the hope that it will be useful,
      12                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14                 :            :  * Library General Public License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU Library General Public
      17                 :            :  * License along with this library; if not, write to the
      18                 :            :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      19                 :            :  * Boston, MA 02111-1307, USA.
      20                 :            :  */
      21                 :            : /**
      22                 :            :  * SECTION:gstcollectpads
      23                 :            :  * @short_description: manages a set of pads that operate in collect mode
      24                 :            :  * @see_also:
      25                 :            :  *
      26                 :            :  * Manages a set of pads that operate in collect mode. This means that control
      27                 :            :  * is given to the manager of this object when all pads have data.
      28                 :            :  * <itemizedlist>
      29                 :            :  *   <listitem><para>
      30                 :            :  *     Collectpads are created with gst_collect_pads_new(). A callback should then
      31                 :            :  *     be installed with gst_collect_pads_set_function ().
      32                 :            :  *   </para></listitem>
      33                 :            :  *   <listitem><para>
      34                 :            :  *     Pads are added to the collection with gst_collect_pads_add_pad()/
      35                 :            :  *     gst_collect_pads_remove_pad(). The pad
      36                 :            :  *     has to be a sinkpad. The chain and event functions of the pad are
      37                 :            :  *     overridden. The element_private of the pad is used to store
      38                 :            :  *     private information for the collectpads.
      39                 :            :  *   </para></listitem>
      40                 :            :  *   <listitem><para>
      41                 :            :  *     For each pad, data is queued in the _chain function or by
      42                 :            :  *     performing a pull_range.
      43                 :            :  *   </para></listitem>
      44                 :            :  *   <listitem><para>
      45                 :            :  *     When data is queued on all pads, the callback function is called.
      46                 :            :  *   </para></listitem>
      47                 :            :  *   <listitem><para>
      48                 :            :  *     Data can be dequeued from the pad with the gst_collect_pads_pop() method.
      49                 :            :  *     One can peek at the data with the gst_collect_pads_peek() function.
      50                 :            :  *     These functions will return NULL if the pad received an EOS event. When all
      51                 :            :  *     pads return NULL from a gst_collect_pads_peek(), the element can emit an EOS
      52                 :            :  *     event itself.
      53                 :            :  *   </para></listitem>
      54                 :            :  *   <listitem><para>
      55                 :            :  *     Data can also be dequeued in byte units using the gst_collect_pads_available(),
      56                 :            :  *     gst_collect_pads_read() and gst_collect_pads_flush() calls.
      57                 :            :  *   </para></listitem>
      58                 :            :  *   <listitem><para>
      59                 :            :  *     Elements should call gst_collect_pads_start() and gst_collect_pads_stop() in
      60                 :            :  *     their state change functions to start and stop the processing of the collecpads.
      61                 :            :  *     The gst_collect_pads_stop() call should be called before calling the parent
      62                 :            :  *     element state change function in the PAUSED_TO_READY state change to ensure
      63                 :            :  *     no pad is blocked and the element can finish streaming.
      64                 :            :  *   </para></listitem>
      65                 :            :  *   <listitem><para>
      66                 :            :  *     gst_collect_pads_collect() and gst_collect_pads_collect_range() can be used by
      67                 :            :  *     elements that start a #GstTask to drive the collect_pads. This feature is however
      68                 :            :  *     not yet implemented.
      69                 :            :  *   </para></listitem>
      70                 :            :  * </itemizedlist>
      71                 :            :  *
      72                 :            :  * Last reviewed on 2006-05-10 (0.10.6)
      73                 :            :  */
      74                 :            : 
      75                 :            : #include "gstcollectpads.h"
      76                 :            : 
      77                 :            : GST_DEBUG_CATEGORY_STATIC (collect_pads_debug);
      78                 :            : #define GST_CAT_DEFAULT collect_pads_debug
      79                 :            : 
      80                 :            : #define GST_COLLECT_PADS_GET_PRIVATE(obj)  \
      81                 :            :   (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_COLLECT_PADS, GstCollectPadsPrivate))
      82                 :            : 
      83                 :            : struct _GstCollectPadsPrivate
      84                 :            : {
      85                 :            :   GstCollectPadsClipFunction clipfunc;
      86                 :            :   gpointer clipfunc_user_data;
      87                 :            : };
      88                 :            : 
      89         [ #  # ]:          0 : GST_BOILERPLATE (GstCollectPads, gst_collect_pads, GstObject, GST_TYPE_OBJECT);
      90                 :            : 
      91                 :            : static void gst_collect_pads_clear (GstCollectPads * pads,
      92                 :            :     GstCollectData * data);
      93                 :            : static GstFlowReturn gst_collect_pads_chain (GstPad * pad, GstBuffer * buffer);
      94                 :            : static gboolean gst_collect_pads_event (GstPad * pad, GstEvent * event);
      95                 :            : static void gst_collect_pads_finalize (GObject * object);
      96                 :            : static void ref_data (GstCollectData * data);
      97                 :            : static void unref_data (GstCollectData * data);
      98                 :            : static void gst_collect_pads_check_pads_unlocked (GstCollectPads * pads);
      99                 :            : 
     100                 :            : static void
     101                 :          0 : gst_collect_pads_base_init (gpointer g_class)
     102                 :            : {
     103                 :            :   /* Do nothing here */
     104                 :          0 : }
     105                 :            : 
     106                 :            : static void
     107                 :          0 : gst_collect_pads_class_init (GstCollectPadsClass * klass)
     108                 :            : {
     109                 :          0 :   GObjectClass *gobject_class = (GObjectClass *) klass;
     110                 :            : 
     111                 :          0 :   g_type_class_add_private (klass, sizeof (GstCollectPadsPrivate));
     112                 :            : 
     113         [ #  # ]:          0 :   GST_DEBUG_CATEGORY_INIT (collect_pads_debug, "collectpads", 0,
     114                 :            :       "GstCollectPads");
     115                 :            : 
     116                 :          0 :   gobject_class->finalize = gst_collect_pads_finalize;
     117                 :          0 : }
     118                 :            : 
     119                 :            : static void
     120                 :          0 : gst_collect_pads_init (GstCollectPads * pads, GstCollectPadsClass * g_class)
     121                 :            : {
     122                 :          0 :   pads->abidata.ABI.priv = GST_COLLECT_PADS_GET_PRIVATE (pads);
     123                 :            : 
     124                 :          0 :   pads->cond = g_cond_new ();
     125                 :          0 :   pads->data = NULL;
     126                 :          0 :   pads->cookie = 0;
     127                 :          0 :   pads->numpads = 0;
     128                 :          0 :   pads->queuedpads = 0;
     129                 :          0 :   pads->eospads = 0;
     130                 :          0 :   pads->started = FALSE;
     131                 :            : 
     132                 :            :   /* members to manage the pad list */
     133                 :          0 :   pads->abidata.ABI.pad_lock = g_mutex_new ();
     134                 :          0 :   pads->abidata.ABI.pad_cookie = 0;
     135                 :          0 :   pads->abidata.ABI.pad_list = NULL;
     136                 :          0 : }
     137                 :            : 
     138                 :            : static void
     139                 :          0 : gst_collect_pads_finalize (GObject * object)
     140                 :            : {
     141                 :            :   GSList *collected;
     142                 :          0 :   GstCollectPads *pads = GST_COLLECT_PADS (object);
     143                 :            : 
     144         [ #  # ]:          0 :   GST_DEBUG ("finalize");
     145                 :            : 
     146                 :          0 :   g_cond_free (pads->cond);
     147                 :          0 :   g_mutex_free (pads->abidata.ABI.pad_lock);
     148                 :            : 
     149                 :            :   /* Remove pads */
     150                 :          0 :   collected = pads->abidata.ABI.pad_list;
     151 [ #  # ][ #  # ]:          0 :   for (; collected; collected = g_slist_next (collected)) {
     152                 :          0 :     GstCollectData *pdata = (GstCollectData *) collected->data;
     153                 :            : 
     154                 :          0 :     unref_data (pdata);
     155                 :            :   }
     156                 :            :   /* Free pads list */
     157                 :          0 :   g_slist_foreach (pads->data, (GFunc) unref_data, NULL);
     158                 :          0 :   g_slist_free (pads->data);
     159                 :          0 :   g_slist_free (pads->abidata.ABI.pad_list);
     160                 :            : 
     161                 :          0 :   G_OBJECT_CLASS (parent_class)->finalize (object);
     162                 :          0 : }
     163                 :            : 
     164                 :            : /**
     165                 :            :  * gst_collect_pads_new:
     166                 :            :  *
     167                 :            :  * Create a new instance of #GstCollectPads.
     168                 :            :  *
     169                 :            :  * MT safe.
     170                 :            :  *
     171                 :            :  * Returns: (transfer full): a new #GstCollectPads, or NULL in case of an error.
     172                 :            :  */
     173                 :            : GstCollectPads *
     174                 :          0 : gst_collect_pads_new (void)
     175                 :            : {
     176                 :            :   GstCollectPads *newcoll;
     177                 :            : 
     178                 :          0 :   newcoll = g_object_newv (GST_TYPE_COLLECT_PADS, 0, NULL);
     179                 :            : 
     180                 :          0 :   return newcoll;
     181                 :            : }
     182                 :            : 
     183                 :            : /**
     184                 :            :  * gst_collect_pads_set_function:
     185                 :            :  * @pads: the collectspads to use
     186                 :            :  * @func: the function to set
     187                 :            :  * @user_data: (closure): user data passed to the function
     188                 :            :  *
     189                 :            :  * Set the callback function and user data that will be called when
     190                 :            :  * all the pads added to the collection have buffers queued.
     191                 :            :  *
     192                 :            :  * MT safe.
     193                 :            :  */
     194                 :            : void
     195                 :          0 : gst_collect_pads_set_function (GstCollectPads * pads,
     196                 :            :     GstCollectPadsFunction func, gpointer user_data)
     197                 :            : {
     198         [ #  # ]:          0 :   g_return_if_fail (pads != NULL);
     199 [ #  # ][ #  # ]:          0 :   g_return_if_fail (GST_IS_COLLECT_PADS (pads));
         [ #  # ][ #  # ]
     200                 :            : 
     201                 :          0 :   GST_OBJECT_LOCK (pads);
     202                 :          0 :   pads->func = func;
     203                 :          0 :   pads->user_data = user_data;
     204                 :          0 :   GST_OBJECT_UNLOCK (pads);
     205                 :            : }
     206                 :            : 
     207                 :            : static void
     208                 :          0 : ref_data (GstCollectData * data)
     209                 :            : {
     210         [ #  # ]:          0 :   g_assert (data != NULL);
     211                 :            : 
     212                 :          0 :   g_atomic_int_inc (&(data->abidata.ABI.refcount));
     213                 :          0 : }
     214                 :            : 
     215                 :            : static void
     216                 :          0 : unref_data (GstCollectData * data)
     217                 :            : {
     218                 :            :   GstCollectDataDestroyNotify destroy_notify;
     219                 :            : 
     220         [ #  # ]:          0 :   g_assert (data != NULL);
     221         [ #  # ]:          0 :   g_assert (data->abidata.ABI.refcount > 0);
     222                 :            : 
     223         [ #  # ]:          0 :   if (!g_atomic_int_dec_and_test (&(data->abidata.ABI.refcount)))
     224                 :          0 :     return;
     225                 :            : 
     226                 :            :   /* FIXME: Ugly hack as we can't add more fields to GstCollectData */
     227                 :          0 :   destroy_notify = (GstCollectDataDestroyNotify)
     228                 :          0 :       g_object_get_data (G_OBJECT (data->pad),
     229                 :            :       "gst-collect-data-destroy-notify");
     230                 :            : 
     231         [ #  # ]:          0 :   if (destroy_notify)
     232                 :          0 :     destroy_notify (data);
     233                 :            : 
     234                 :          0 :   g_object_unref (data->pad);
     235         [ #  # ]:          0 :   if (data->buffer) {
     236                 :          0 :     gst_buffer_unref (data->buffer);
     237                 :            :   }
     238                 :          0 :   g_free (data);
     239                 :            : }
     240                 :            : 
     241                 :            : /**
     242                 :            :  * gst_collect_pads_add_pad:
     243                 :            :  * @pads: the collectspads to use
     244                 :            :  * @pad: (transfer none): the pad to add
     245                 :            :  * @size: the size of the returned #GstCollectData structure
     246                 :            :  *
     247                 :            :  * Add a pad to the collection of collect pads. The pad has to be
     248                 :            :  * a sinkpad. The refcount of the pad is incremented. Use
     249                 :            :  * gst_collect_pads_remove_pad() to remove the pad from the collection
     250                 :            :  * again.
     251                 :            :  *
     252                 :            :  * This function will override the chain and event functions of the pad
     253                 :            :  * along with the element_private data, which is used to store private
     254                 :            :  * information for the collectpads.
     255                 :            :  *
     256                 :            :  * You specify a size for the returned #GstCollectData structure
     257                 :            :  * so that you can use it to store additional information.
     258                 :            :  *
     259                 :            :  * The pad will be automatically activated in push mode when @pads is
     260                 :            :  * started.
     261                 :            :  *
     262                 :            :  * This function calls gst_collect_pads_add_pad_full() passing a value of NULL
     263                 :            :  * for destroy_notify.
     264                 :            :  *
     265                 :            :  * MT safe.
     266                 :            :  *
     267                 :            :  * Returns: a new #GstCollectData to identify the new pad. Or NULL
     268                 :            :  *   if wrong parameters are supplied.
     269                 :            :  */
     270                 :            : GstCollectData *
     271                 :          0 : gst_collect_pads_add_pad (GstCollectPads * pads, GstPad * pad, guint size)
     272                 :            : {
     273                 :          0 :   return gst_collect_pads_add_pad_full (pads, pad, size, NULL);
     274                 :            : }
     275                 :            : 
     276                 :            : /**
     277                 :            :  * gst_collect_pads_add_pad_full:
     278                 :            :  * @pads: the collectspads to use
     279                 :            :  * @pad: (transfer none): the pad to add
     280                 :            :  * @size: the size of the returned #GstCollectData structure
     281                 :            :  * @destroy_notify: function to be called before the returned #GstCollectData
     282                 :            :  * structure is freed
     283                 :            :  *
     284                 :            :  * Add a pad to the collection of collect pads. The pad has to be
     285                 :            :  * a sinkpad. The refcount of the pad is incremented. Use
     286                 :            :  * gst_collect_pads_remove_pad() to remove the pad from the collection
     287                 :            :  * again.
     288                 :            :  *
     289                 :            :  * You specify a size for the returned #GstCollectData structure
     290                 :            :  * so that you can use it to store additional information.
     291                 :            :  *
     292                 :            :  * You can also specify a #GstCollectDataDestroyNotify that will be called
     293                 :            :  * just before the #GstCollectData structure is freed. It is passed the
     294                 :            :  * pointer to the structure and should free any custom memory and resources
     295                 :            :  * allocated for it.
     296                 :            :  *
     297                 :            :  * The pad will be automatically activated in push mode when @pads is
     298                 :            :  * started.
     299                 :            :  *
     300                 :            :  * MT safe.
     301                 :            :  *
     302                 :            :  * Since: 0.10.12
     303                 :            :  *
     304                 :            :  * Returns: a new #GstCollectData to identify the new pad. Or NULL
     305                 :            :  *   if wrong parameters are supplied.
     306                 :            :  */
     307                 :            : GstCollectData *
     308                 :          0 : gst_collect_pads_add_pad_full (GstCollectPads * pads, GstPad * pad, guint size,
     309                 :            :     GstCollectDataDestroyNotify destroy_notify)
     310                 :            : {
     311                 :            :   GstCollectData *data;
     312                 :            : 
     313         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, NULL);
     314 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), NULL);
         [ #  # ][ #  # ]
     315         [ #  # ]:          0 :   g_return_val_if_fail (pad != NULL, NULL);
     316         [ #  # ]:          0 :   g_return_val_if_fail (GST_PAD_IS_SINK (pad), NULL);
     317         [ #  # ]:          0 :   g_return_val_if_fail (size >= sizeof (GstCollectData), NULL);
     318                 :            : 
     319 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("adding pad %s:%s", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     320                 :            : 
     321                 :          0 :   data = g_malloc0 (size);
     322                 :          0 :   data->collect = pads;
     323                 :          0 :   data->pad = gst_object_ref (pad);
     324                 :          0 :   data->buffer = NULL;
     325                 :          0 :   data->pos = 0;
     326                 :          0 :   gst_segment_init (&data->segment, GST_FORMAT_UNDEFINED);
     327                 :          0 :   data->abidata.ABI.flushing = FALSE;
     328                 :          0 :   data->abidata.ABI.new_segment = FALSE;
     329                 :          0 :   data->abidata.ABI.eos = FALSE;
     330                 :          0 :   data->abidata.ABI.refcount = 1;
     331                 :            : 
     332                 :            :   /* FIXME: Ugly hack as we can't add more fields to GstCollectData */
     333                 :          0 :   g_object_set_data (G_OBJECT (pad), "gst-collect-data-destroy-notify",
     334                 :            :       (void *) destroy_notify);
     335                 :            : 
     336                 :          0 :   GST_COLLECT_PADS_PAD_LOCK (pads);
     337                 :          0 :   GST_OBJECT_LOCK (pad);
     338                 :          0 :   gst_pad_set_element_private (pad, data);
     339                 :          0 :   GST_OBJECT_UNLOCK (pad);
     340                 :          0 :   pads->abidata.ABI.pad_list =
     341                 :          0 :       g_slist_append (pads->abidata.ABI.pad_list, data);
     342                 :          0 :   gst_pad_set_chain_function (pad, GST_DEBUG_FUNCPTR (gst_collect_pads_chain));
     343                 :          0 :   gst_pad_set_event_function (pad, GST_DEBUG_FUNCPTR (gst_collect_pads_event));
     344                 :            :   /* activate the pad when needed */
     345         [ #  # ]:          0 :   if (pads->started)
     346                 :          0 :     gst_pad_set_active (pad, TRUE);
     347                 :          0 :   pads->abidata.ABI.pad_cookie++;
     348                 :          0 :   GST_COLLECT_PADS_PAD_UNLOCK (pads);
     349                 :            : 
     350                 :          0 :   return data;
     351                 :            : }
     352                 :            : 
     353                 :            : static gint
     354                 :          0 : find_pad (GstCollectData * data, GstPad * pad)
     355                 :            : {
     356         [ #  # ]:          0 :   if (data->pad == pad)
     357                 :          0 :     return 0;
     358                 :          0 :   return 1;
     359                 :            : }
     360                 :            : 
     361                 :            : /**
     362                 :            :  * gst_collect_pads_set_clip_function:
     363                 :            :  * @pads: the collectspads to use
     364                 :            :  * @clipfunc: clip function to install
     365                 :            :  * @user_data: (closure): user data to pass to @clip_func
     366                 :            :  *
     367                 :            :  * Install a clipping function that is called right after a buffer is received
     368                 :            :  * on a pad managed by @pads. See #GstCollectPadsClipFunction for more info.
     369                 :            :  *
     370                 :            :  * Since: 0.10.26
     371                 :            :  */
     372                 :            : void
     373                 :          0 : gst_collect_pads_set_clip_function (GstCollectPads * pads,
     374                 :            :     GstCollectPadsClipFunction clipfunc, gpointer user_data)
     375                 :            : {
     376                 :            :   GstCollectPadsPrivate *priv;
     377                 :            : 
     378         [ #  # ]:          0 :   g_return_if_fail (pads != NULL);
     379 [ #  # ][ #  # ]:          0 :   g_return_if_fail (GST_IS_COLLECT_PADS (pads));
         [ #  # ][ #  # ]
     380                 :            : 
     381                 :          0 :   priv = pads->abidata.ABI.priv;
     382                 :            : 
     383                 :          0 :   priv->clipfunc = clipfunc;
     384                 :          0 :   priv->clipfunc_user_data = user_data;
     385                 :            : }
     386                 :            : 
     387                 :            : /**
     388                 :            :  * gst_collect_pads_remove_pad:
     389                 :            :  * @pads: the collectspads to use
     390                 :            :  * @pad: (transfer none): the pad to remove
     391                 :            :  *
     392                 :            :  * Remove a pad from the collection of collect pads. This function will also
     393                 :            :  * free the #GstCollectData and all the resources that were allocated with
     394                 :            :  * gst_collect_pads_add_pad().
     395                 :            :  *
     396                 :            :  * The pad will be deactivated automatically when @pads is stopped.
     397                 :            :  *
     398                 :            :  * MT safe.
     399                 :            :  *
     400                 :            :  * Returns: %TRUE if the pad could be removed.
     401                 :            :  */
     402                 :            : gboolean
     403                 :          0 : gst_collect_pads_remove_pad (GstCollectPads * pads, GstPad * pad)
     404                 :            : {
     405                 :            :   GstCollectData *data;
     406                 :            :   GSList *list;
     407                 :            : 
     408         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, FALSE);
     409 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), FALSE);
         [ #  # ][ #  # ]
     410         [ #  # ]:          0 :   g_return_val_if_fail (pad != NULL, FALSE);
     411 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
         [ #  # ][ #  # ]
     412                 :            : 
     413 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("removing pad %s:%s", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     414                 :            : 
     415                 :          0 :   GST_COLLECT_PADS_PAD_LOCK (pads);
     416                 :          0 :   list =
     417                 :          0 :       g_slist_find_custom (pads->abidata.ABI.pad_list, pad,
     418                 :            :       (GCompareFunc) find_pad);
     419         [ #  # ]:          0 :   if (!list)
     420                 :          0 :     goto unknown_pad;
     421                 :            : 
     422                 :          0 :   data = (GstCollectData *) list->data;
     423                 :            : 
     424 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("found pad %s:%s at %p", GST_DEBUG_PAD_NAME (pad), data);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     425                 :            : 
     426                 :            :   /* clear the stuff we configured */
     427                 :          0 :   gst_pad_set_chain_function (pad, NULL);
     428                 :          0 :   gst_pad_set_event_function (pad, NULL);
     429                 :          0 :   GST_OBJECT_LOCK (pad);
     430                 :          0 :   gst_pad_set_element_private (pad, NULL);
     431                 :          0 :   GST_OBJECT_UNLOCK (pad);
     432                 :            : 
     433                 :            :   /* backward compat, also remove from data if stopped, note that this function
     434                 :            :    * can only be called when we are stopped because we don't take the LOCK to
     435                 :            :    * protect the pads->data list. */
     436         [ #  # ]:          0 :   if (!pads->started) {
     437                 :            :     GSList *dlist;
     438                 :            : 
     439                 :          0 :     dlist = g_slist_find_custom (pads->data, pad, (GCompareFunc) find_pad);
     440         [ #  # ]:          0 :     if (dlist) {
     441                 :          0 :       GstCollectData *pdata = dlist->data;
     442                 :            : 
     443                 :          0 :       pads->data = g_slist_delete_link (pads->data, dlist);
     444                 :          0 :       unref_data (pdata);
     445                 :            :     }
     446                 :            :   }
     447                 :            :   /* remove from the pad list */
     448                 :          0 :   pads->abidata.ABI.pad_list =
     449                 :          0 :       g_slist_delete_link (pads->abidata.ABI.pad_list, list);
     450                 :          0 :   pads->abidata.ABI.pad_cookie++;
     451                 :            : 
     452                 :            :   /* signal waiters because something changed */
     453                 :          0 :   GST_COLLECT_PADS_BROADCAST (pads);
     454                 :            : 
     455                 :            :   /* deactivate the pad when needed */
     456         [ #  # ]:          0 :   if (!pads->started)
     457                 :          0 :     gst_pad_set_active (pad, FALSE);
     458                 :            : 
     459                 :            :   /* clean and free the collect data */
     460                 :          0 :   unref_data (data);
     461                 :            : 
     462                 :          0 :   GST_COLLECT_PADS_PAD_UNLOCK (pads);
     463                 :            : 
     464                 :          0 :   return TRUE;
     465                 :            : 
     466                 :            : unknown_pad:
     467                 :            :   {
     468 [ #  # ][ #  # ]:          0 :     GST_WARNING ("cannot remove unknown pad %s:%s", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     469                 :          0 :     GST_COLLECT_PADS_PAD_UNLOCK (pads);
     470                 :          0 :     return FALSE;
     471                 :            :   }
     472                 :            : }
     473                 :            : 
     474                 :            : /**
     475                 :            :  * gst_collect_pads_is_active:
     476                 :            :  * @pads: (transfer none): the collectspads to use
     477                 :            :  * @pad: the pad to check
     478                 :            :  *
     479                 :            :  * Check if a pad is active.
     480                 :            :  *
     481                 :            :  * This function is currently not implemented.
     482                 :            :  *
     483                 :            :  * MT safe.
     484                 :            :  *
     485                 :            :  * Returns: %TRUE if the pad is active.
     486                 :            :  */
     487                 :            : gboolean
     488                 :          0 : gst_collect_pads_is_active (GstCollectPads * pads, GstPad * pad)
     489                 :            : {
     490         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, FALSE);
     491 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), FALSE);
         [ #  # ][ #  # ]
     492         [ #  # ]:          0 :   g_return_val_if_fail (pad != NULL, FALSE);
     493 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
         [ #  # ][ #  # ]
     494                 :            : 
     495                 :          0 :   g_warning ("gst_collect_pads_is_active() is not implemented");
     496                 :            : 
     497                 :          0 :   return FALSE;
     498                 :            : }
     499                 :            : 
     500                 :            : /**
     501                 :            :  * gst_collect_pads_collect:
     502                 :            :  * @pads: the collectspads to use
     503                 :            :  *
     504                 :            :  * Collect data on all pads. This function is usually called
     505                 :            :  * from a #GstTask function in an element.
     506                 :            :  *
     507                 :            :  * This function is currently not implemented.
     508                 :            :  *
     509                 :            :  * MT safe.
     510                 :            :  *
     511                 :            :  * Returns: #GstFlowReturn of the operation.
     512                 :            :  */
     513                 :            : GstFlowReturn
     514                 :          0 : gst_collect_pads_collect (GstCollectPads * pads)
     515                 :            : {
     516         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, GST_FLOW_ERROR);
     517 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), GST_FLOW_ERROR);
         [ #  # ][ #  # ]
     518                 :            : 
     519                 :          0 :   g_warning ("gst_collect_pads_collect() is not implemented");
     520                 :            : 
     521                 :          0 :   return GST_FLOW_NOT_SUPPORTED;
     522                 :            : }
     523                 :            : 
     524                 :            : /**
     525                 :            :  * gst_collect_pads_collect_range:
     526                 :            :  * @pads: the collectspads to use
     527                 :            :  * @offset: the offset to collect
     528                 :            :  * @length: the length to collect
     529                 :            :  *
     530                 :            :  * Collect data with @offset and @length on all pads. This function
     531                 :            :  * is typically called in the getrange function of an element.
     532                 :            :  *
     533                 :            :  * This function is currently not implemented.
     534                 :            :  *
     535                 :            :  * MT safe.
     536                 :            :  *
     537                 :            :  * Returns: #GstFlowReturn of the operation.
     538                 :            :  */
     539                 :            : GstFlowReturn
     540                 :          0 : gst_collect_pads_collect_range (GstCollectPads * pads, guint64 offset,
     541                 :            :     guint length)
     542                 :            : {
     543         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, GST_FLOW_ERROR);
     544 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), GST_FLOW_ERROR);
         [ #  # ][ #  # ]
     545                 :            : 
     546                 :          0 :   g_warning ("gst_collect_pads_collect_range() is not implemented");
     547                 :            : 
     548                 :          0 :   return GST_FLOW_NOT_SUPPORTED;
     549                 :            : }
     550                 :            : 
     551                 :            : static gboolean
     552                 :          0 : gst_collect_pads_is_flushing (GstCollectPads * pads)
     553                 :            : {
     554                 :          0 :   GSList *walk = NULL;
     555                 :          0 :   gboolean res = TRUE;
     556                 :            : 
     557                 :          0 :   GST_COLLECT_PADS_PAD_LOCK (pads);
     558                 :            : 
     559                 :            :   /* Ensure pads->data state */
     560                 :          0 :   gst_collect_pads_check_pads_unlocked (pads);
     561                 :            : 
     562         [ #  # ]:          0 :   GST_DEBUG ("Getting flushing state (pads:%p, pads->data:%p)",
     563                 :            :       pads, pads->data);
     564                 :            : 
     565 [ #  # ][ #  # ]:          0 :   for (walk = pads->data; walk; walk = g_slist_next (walk)) {
     566                 :          0 :     GstCollectData *cdata = walk->data;
     567                 :            : 
     568         [ #  # ]:          0 :     GST_DEBUG_OBJECT (cdata->pad, "flushing:%d", cdata->abidata.ABI.flushing);
     569                 :            : 
     570         [ #  # ]:          0 :     if (cdata->abidata.ABI.flushing) {
     571                 :          0 :       goto done;
     572                 :            :     }
     573                 :            :   }
     574                 :            : 
     575                 :          0 :   res = FALSE;
     576                 :            : done:
     577                 :          0 :   GST_COLLECT_PADS_PAD_UNLOCK (pads);
     578                 :          0 :   return res;
     579                 :            : }
     580                 :            : 
     581                 :            : /* FIXME, I think this function is used to work around bad behaviour
     582                 :            :  * of elements that add pads to themselves without activating them.
     583                 :            :  *
     584                 :            :  * Must be called with PAD_LOCK.
     585                 :            :  */
     586                 :            : static void
     587                 :          0 : gst_collect_pads_set_flushing_unlocked (GstCollectPads * pads,
     588                 :            :     gboolean flushing)
     589                 :            : {
     590                 :          0 :   GSList *walk = NULL;
     591                 :            : 
     592         [ #  # ]:          0 :   GST_DEBUG ("Setting flushing (%d)", flushing);
     593                 :            : 
     594                 :            :   /* Update the pads flushing flag */
     595 [ #  # ][ #  # ]:          0 :   for (walk = pads->data; walk; walk = g_slist_next (walk)) {
     596                 :          0 :     GstCollectData *cdata = walk->data;
     597                 :            : 
     598 [ #  # ][ #  # ]:          0 :     if (GST_IS_PAD (cdata->pad)) {
         [ #  # ][ #  # ]
     599                 :          0 :       GST_OBJECT_LOCK (cdata->pad);
     600         [ #  # ]:          0 :       if (flushing)
     601                 :          0 :         GST_PAD_SET_FLUSHING (cdata->pad);
     602                 :            :       else
     603                 :          0 :         GST_PAD_UNSET_FLUSHING (cdata->pad);
     604                 :          0 :       cdata->abidata.ABI.flushing = flushing;
     605                 :          0 :       gst_collect_pads_clear (pads, cdata);
     606                 :          0 :       GST_OBJECT_UNLOCK (cdata->pad);
     607                 :            :     }
     608                 :            :   }
     609                 :            :   /* Setting the pads to flushing means that we changed the values which
     610                 :            :    * are 'protected' by the cookie. We therefore update it to force a
     611                 :            :    * recalculation of the current pad status. */
     612                 :          0 :   pads->abidata.ABI.pad_cookie++;
     613                 :          0 : }
     614                 :            : 
     615                 :            : /**
     616                 :            :  * gst_collect_pads_set_flushing:
     617                 :            :  * @pads: the collectspads to use
     618                 :            :  * @flushing: desired state of the pads
     619                 :            :  *
     620                 :            :  * Change the flushing state of all the pads in the collection. No pad
     621                 :            :  * is able to accept anymore data when @flushing is %TRUE. Calling this
     622                 :            :  * function with @flushing %FALSE makes @pads accept data again.
     623                 :            :  *
     624                 :            :  * MT safe.
     625                 :            :  *
     626                 :            :  * Since: 0.10.7.
     627                 :            :  */
     628                 :            : void
     629                 :          0 : gst_collect_pads_set_flushing (GstCollectPads * pads, gboolean flushing)
     630                 :            : {
     631         [ #  # ]:          0 :   g_return_if_fail (pads != NULL);
     632 [ #  # ][ #  # ]:          0 :   g_return_if_fail (GST_IS_COLLECT_PADS (pads));
         [ #  # ][ #  # ]
     633                 :            : 
     634                 :          0 :   GST_COLLECT_PADS_PAD_LOCK (pads);
     635                 :            :   /* Ensure pads->data state */
     636                 :          0 :   gst_collect_pads_check_pads_unlocked (pads);
     637                 :          0 :   gst_collect_pads_set_flushing_unlocked (pads, flushing);
     638                 :          0 :   GST_COLLECT_PADS_PAD_UNLOCK (pads);
     639                 :            : }
     640                 :            : 
     641                 :            : /**
     642                 :            :  * gst_collect_pads_start:
     643                 :            :  * @pads: the collectspads to use
     644                 :            :  *
     645                 :            :  * Starts the processing of data in the collect_pads.
     646                 :            :  *
     647                 :            :  * MT safe.
     648                 :            :  */
     649                 :            : void
     650                 :          0 : gst_collect_pads_start (GstCollectPads * pads)
     651                 :            : {
     652                 :            :   GSList *collected;
     653                 :            : 
     654         [ #  # ]:          0 :   g_return_if_fail (pads != NULL);
     655 [ #  # ][ #  # ]:          0 :   g_return_if_fail (GST_IS_COLLECT_PADS (pads));
         [ #  # ][ #  # ]
     656                 :            : 
     657         [ #  # ]:          0 :   GST_DEBUG_OBJECT (pads, "starting collect pads");
     658                 :            : 
     659                 :            :   /* make sure stop and collect cannot be called anymore */
     660                 :          0 :   GST_OBJECT_LOCK (pads);
     661                 :            : 
     662                 :            :   /* make pads streamable */
     663                 :          0 :   GST_COLLECT_PADS_PAD_LOCK (pads);
     664                 :            : 
     665                 :            :   /* loop over the master pad list and reset the segment */
     666                 :          0 :   collected = pads->abidata.ABI.pad_list;
     667 [ #  # ][ #  # ]:          0 :   for (; collected; collected = g_slist_next (collected)) {
     668                 :            :     GstCollectData *data;
     669                 :            : 
     670                 :          0 :     data = collected->data;
     671                 :          0 :     gst_segment_init (&data->segment, GST_FORMAT_UNDEFINED);
     672                 :            :   }
     673                 :            : 
     674                 :          0 :   gst_collect_pads_set_flushing_unlocked (pads, FALSE);
     675                 :            : 
     676                 :            :   /* Start collect pads */
     677                 :          0 :   pads->started = TRUE;
     678                 :          0 :   GST_COLLECT_PADS_PAD_UNLOCK (pads);
     679                 :          0 :   GST_OBJECT_UNLOCK (pads);
     680                 :            : }
     681                 :            : 
     682                 :            : /**
     683                 :            :  * gst_collect_pads_stop:
     684                 :            :  * @pads: the collectspads to use
     685                 :            :  *
     686                 :            :  * Stops the processing of data in the collect_pads. this function
     687                 :            :  * will also unblock any blocking operations.
     688                 :            :  *
     689                 :            :  * MT safe.
     690                 :            :  */
     691                 :            : void
     692                 :          0 : gst_collect_pads_stop (GstCollectPads * pads)
     693                 :            : {
     694                 :            :   GSList *collected;
     695                 :            : 
     696         [ #  # ]:          0 :   g_return_if_fail (pads != NULL);
     697 [ #  # ][ #  # ]:          0 :   g_return_if_fail (GST_IS_COLLECT_PADS (pads));
         [ #  # ][ #  # ]
     698                 :            : 
     699         [ #  # ]:          0 :   GST_DEBUG_OBJECT (pads, "stopping collect pads");
     700                 :            : 
     701                 :            :   /* make sure collect and start cannot be called anymore */
     702                 :          0 :   GST_OBJECT_LOCK (pads);
     703                 :            : 
     704                 :            :   /* make pads not accept data anymore */
     705                 :          0 :   GST_COLLECT_PADS_PAD_LOCK (pads);
     706                 :          0 :   gst_collect_pads_set_flushing_unlocked (pads, TRUE);
     707                 :            : 
     708                 :            :   /* Stop collect pads */
     709                 :          0 :   pads->started = FALSE;
     710                 :          0 :   pads->eospads = 0;
     711                 :          0 :   pads->queuedpads = 0;
     712                 :            : 
     713                 :            :   /* loop over the master pad list and flush buffers */
     714                 :          0 :   collected = pads->abidata.ABI.pad_list;
     715 [ #  # ][ #  # ]:          0 :   for (; collected; collected = g_slist_next (collected)) {
     716                 :            :     GstCollectData *data;
     717                 :            :     GstBuffer **buffer_p;
     718                 :            : 
     719                 :          0 :     data = collected->data;
     720         [ #  # ]:          0 :     if (data->buffer) {
     721                 :          0 :       buffer_p = &data->buffer;
     722                 :          0 :       gst_buffer_replace (buffer_p, NULL);
     723                 :          0 :       data->pos = 0;
     724                 :            :     }
     725                 :          0 :     data->abidata.ABI.eos = FALSE;
     726                 :            :   }
     727                 :            : 
     728                 :          0 :   GST_COLLECT_PADS_PAD_UNLOCK (pads);
     729                 :            :   /* Wake them up so they can end the chain functions. */
     730                 :          0 :   GST_COLLECT_PADS_BROADCAST (pads);
     731                 :            : 
     732                 :          0 :   GST_OBJECT_UNLOCK (pads);
     733                 :            : }
     734                 :            : 
     735                 :            : /**
     736                 :            :  * gst_collect_pads_peek:
     737                 :            :  * @pads: the collectspads to peek
     738                 :            :  * @data: the data to use
     739                 :            :  *
     740                 :            :  * Peek at the buffer currently queued in @data. This function
     741                 :            :  * should be called with the @pads LOCK held, such as in the callback
     742                 :            :  * handler.
     743                 :            :  *
     744                 :            :  * MT safe.
     745                 :            :  *
     746                 :            :  * Returns: (transfer full): The buffer in @data or NULL if no buffer is queued.
     747                 :            :  *  should unref the buffer after usage.
     748                 :            :  */
     749                 :            : GstBuffer *
     750                 :          0 : gst_collect_pads_peek (GstCollectPads * pads, GstCollectData * data)
     751                 :            : {
     752                 :            :   GstBuffer *result;
     753                 :            : 
     754         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, NULL);
     755 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), NULL);
         [ #  # ][ #  # ]
     756         [ #  # ]:          0 :   g_return_val_if_fail (data != NULL, NULL);
     757                 :            : 
     758         [ #  # ]:          0 :   if ((result = data->buffer))
     759                 :          0 :     gst_buffer_ref (result);
     760                 :            : 
     761 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("Peeking at pad %s:%s: buffer=%p",
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     762                 :            :       GST_DEBUG_PAD_NAME (data->pad), result);
     763                 :            : 
     764                 :          0 :   return result;
     765                 :            : }
     766                 :            : 
     767                 :            : /**
     768                 :            :  * gst_collect_pads_pop:
     769                 :            :  * @pads: the collectspads to pop
     770                 :            :  * @data: the data to use
     771                 :            :  *
     772                 :            :  * Pop the buffer currently queued in @data. This function
     773                 :            :  * should be called with the @pads LOCK held, such as in the callback
     774                 :            :  * handler.
     775                 :            :  *
     776                 :            :  * Free-function: gst_buffer_unref
     777                 :            :  *
     778                 :            :  * MT safe.
     779                 :            :  *
     780                 :            :  * Returns: (transfer full): The buffer in @data or NULL if no buffer was
     781                 :            :  *   queued. You should unref the buffer after usage.
     782                 :            :  */
     783                 :            : GstBuffer *
     784                 :          0 : gst_collect_pads_pop (GstCollectPads * pads, GstCollectData * data)
     785                 :            : {
     786                 :            :   GstBuffer *result;
     787                 :            : 
     788         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, NULL);
     789 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), NULL);
         [ #  # ][ #  # ]
     790         [ #  # ]:          0 :   g_return_val_if_fail (data != NULL, NULL);
     791                 :            : 
     792         [ #  # ]:          0 :   if ((result = data->buffer)) {
     793                 :          0 :     data->buffer = NULL;
     794                 :          0 :     data->pos = 0;
     795                 :            :     /* one less pad with queued data now */
     796                 :          0 :     pads->queuedpads--;
     797                 :            :   }
     798                 :            : 
     799                 :          0 :   GST_COLLECT_PADS_BROADCAST (pads);
     800                 :            : 
     801 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("Pop buffer on pad %s:%s: buffer=%p",
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     802                 :            :       GST_DEBUG_PAD_NAME (data->pad), result);
     803                 :            : 
     804                 :          0 :   return result;
     805                 :            : }
     806                 :            : 
     807                 :            : /* pop and unref the currently queued buffer, should e called with the LOCK
     808                 :            :  * helt. */
     809                 :            : static void
     810                 :          0 : gst_collect_pads_clear (GstCollectPads * pads, GstCollectData * data)
     811                 :            : {
     812                 :            :   GstBuffer *buf;
     813                 :            : 
     814         [ #  # ]:          0 :   if ((buf = gst_collect_pads_pop (pads, data)))
     815                 :          0 :     gst_buffer_unref (buf);
     816                 :          0 : }
     817                 :            : 
     818                 :            : /**
     819                 :            :  * gst_collect_pads_available:
     820                 :            :  * @pads: the collectspads to query
     821                 :            :  *
     822                 :            :  * Query how much bytes can be read from each queued buffer. This means
     823                 :            :  * that the result of this call is the maximum number of bytes that can
     824                 :            :  * be read from each of the pads.
     825                 :            :  *
     826                 :            :  * This function should be called with @pads LOCK held, such as
     827                 :            :  * in the callback.
     828                 :            :  *
     829                 :            :  * MT safe.
     830                 :            :  *
     831                 :            :  * Returns: The maximum number of bytes queued on all pads. This function
     832                 :            :  * returns 0 if a pad has no queued buffer.
     833                 :            :  */
     834                 :            : /* FIXME, we can do this in the _chain functions */
     835                 :            : guint
     836                 :          0 : gst_collect_pads_available (GstCollectPads * pads)
     837                 :            : {
     838                 :            :   GSList *collected;
     839                 :          0 :   guint result = G_MAXUINT;
     840                 :            : 
     841         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, 0);
     842 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), 0);
         [ #  # ][ #  # ]
     843                 :            : 
     844 [ #  # ][ #  # ]:          0 :   for (collected = pads->data; collected; collected = g_slist_next (collected)) {
     845                 :            :     GstCollectData *pdata;
     846                 :            :     GstBuffer *buffer;
     847                 :            :     gint size;
     848                 :            : 
     849                 :          0 :     pdata = (GstCollectData *) collected->data;
     850                 :            : 
     851                 :            :     /* ignore pad with EOS */
     852         [ #  # ]:          0 :     if (G_UNLIKELY (pdata->abidata.ABI.eos)) {
     853 [ #  # ][ #  # ]:          0 :       GST_DEBUG ("pad %s:%s is EOS", GST_DEBUG_PAD_NAME (pdata->pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     854                 :          0 :       continue;
     855                 :            :     }
     856                 :            : 
     857                 :            :     /* an empty buffer without EOS is weird when we get here.. */
     858         [ #  # ]:          0 :     if (G_UNLIKELY ((buffer = pdata->buffer) == NULL)) {
     859 [ #  # ][ #  # ]:          0 :       GST_WARNING ("pad %s:%s has no buffer", GST_DEBUG_PAD_NAME (pdata->pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     860                 :          0 :       goto not_filled;
     861                 :            :     }
     862                 :            : 
     863                 :            :     /* this is the size left of the buffer */
     864                 :          0 :     size = GST_BUFFER_SIZE (buffer) - pdata->pos;
     865 [ #  # ][ #  # ]:          0 :     GST_DEBUG ("pad %s:%s has %d bytes left",
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     866                 :            :         GST_DEBUG_PAD_NAME (pdata->pad), size);
     867                 :            : 
     868                 :            :     /* need to return the min of all available data */
     869         [ #  # ]:          0 :     if (size < result)
     870                 :          0 :       result = size;
     871                 :            :   }
     872                 :            :   /* nothing changed, all must be EOS then, return 0 */
     873         [ #  # ]:          0 :   if (G_UNLIKELY (result == G_MAXUINT))
     874                 :          0 :     result = 0;
     875                 :            : 
     876                 :          0 :   return result;
     877                 :            : 
     878                 :            : not_filled:
     879                 :            :   {
     880                 :          0 :     return 0;
     881                 :            :   }
     882                 :            : }
     883                 :            : 
     884                 :            : /**
     885                 :            :  * gst_collect_pads_read:
     886                 :            :  * @pads: the collectspads to query
     887                 :            :  * @data: the data to use
     888                 :            :  * @bytes: (out) (transfer none) (array length=size): a pointer to a byte array
     889                 :            :  * @size: the number of bytes to read
     890                 :            :  *
     891                 :            :  * Get a pointer in @bytes where @size bytes can be read from the
     892                 :            :  * given pad @data.
     893                 :            :  *
     894                 :            :  * This function should be called with @pads LOCK held, such as
     895                 :            :  * in the callback.
     896                 :            :  *
     897                 :            :  * MT safe.
     898                 :            :  *
     899                 :            :  * Returns: The number of bytes available for consumption in the
     900                 :            :  * memory pointed to by @bytes. This can be less than @size and
     901                 :            :  * is 0 if the pad is end-of-stream.
     902                 :            :  */
     903                 :            : guint
     904                 :          0 : gst_collect_pads_read (GstCollectPads * pads, GstCollectData * data,
     905                 :            :     guint8 ** bytes, guint size)
     906                 :            : {
     907                 :            :   guint readsize;
     908                 :            :   GstBuffer *buffer;
     909                 :            : 
     910         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, 0);
     911 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), 0);
         [ #  # ][ #  # ]
     912         [ #  # ]:          0 :   g_return_val_if_fail (data != NULL, 0);
     913         [ #  # ]:          0 :   g_return_val_if_fail (bytes != NULL, 0);
     914                 :            : 
     915                 :            :   /* no buffer, must be EOS */
     916         [ #  # ]:          0 :   if ((buffer = data->buffer) == NULL)
     917                 :          0 :     return 0;
     918                 :            : 
     919                 :          0 :   readsize = MIN (size, GST_BUFFER_SIZE (buffer) - data->pos);
     920                 :            : 
     921                 :          0 :   *bytes = GST_BUFFER_DATA (buffer) + data->pos;
     922                 :            : 
     923                 :          0 :   return readsize;
     924                 :            : }
     925                 :            : 
     926                 :            : /**
     927                 :            :  * gst_collect_pads_read_buffer:
     928                 :            :  * @pads: the collectspads to query
     929                 :            :  * @data: the data to use
     930                 :            :  * @size: the number of bytes to read
     931                 :            :  *
     932                 :            :  * Get a buffer of @size bytes from the given pad @data.
     933                 :            :  *
     934                 :            :  * This function should be called with @pads LOCK held, such as in the callback.
     935                 :            :  *
     936                 :            :  * Free-function: gst_buffer_unref
     937                 :            :  *
     938                 :            :  * Returns: (transfer full): a #GstBuffer. The size of the buffer can be less
     939                 :            :  *     that requested. A return of NULL signals that the pad is end-of-stream.
     940                 :            :  *     Unref the buffer with gst_buffer_unref() after use.
     941                 :            :  *
     942                 :            :  * MT safe.
     943                 :            :  *
     944                 :            :  * Since: 0.10.18
     945                 :            :  */
     946                 :            : GstBuffer *
     947                 :          0 : gst_collect_pads_read_buffer (GstCollectPads * pads, GstCollectData * data,
     948                 :            :     guint size)
     949                 :            : {
     950                 :            :   guint readsize, bufsize;
     951                 :            :   GstBuffer *buffer;
     952                 :            : 
     953         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, NULL);
     954 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), NULL);
         [ #  # ][ #  # ]
     955         [ #  # ]:          0 :   g_return_val_if_fail (data != NULL, NULL);
     956                 :            : 
     957                 :            :   /* no buffer, must be EOS */
     958         [ #  # ]:          0 :   if ((buffer = data->buffer) == NULL)
     959                 :          0 :     return NULL;
     960                 :            : 
     961                 :          0 :   bufsize = GST_BUFFER_SIZE (buffer);
     962                 :            : 
     963                 :          0 :   readsize = MIN (size, bufsize - data->pos);
     964                 :            : 
     965 [ #  # ][ #  # ]:          0 :   if (data->pos == 0 && readsize == bufsize)
     966                 :          0 :     return gst_buffer_ref (buffer);
     967                 :            :   else
     968                 :          0 :     return gst_buffer_create_sub (buffer, data->pos, readsize);
     969                 :            : }
     970                 :            : 
     971                 :            : /**
     972                 :            :  * gst_collect_pads_take_buffer:
     973                 :            :  * @pads: the collectspads to query
     974                 :            :  * @data: the data to use
     975                 :            :  * @size: the number of bytes to read
     976                 :            :  *
     977                 :            :  * Get a buffer of @size bytes from the given pad @data. Flushes the amount
     978                 :            :  * of read bytes.
     979                 :            :  *
     980                 :            :  * This function should be called with @pads LOCK held, such as in the callback.
     981                 :            :  *
     982                 :            :  * Free-function: gst_buffer_unref
     983                 :            :  *
     984                 :            :  * MT safe.
     985                 :            :  *
     986                 :            :  * Returns: (transfer full): a #GstBuffer. The size of the buffer can be less
     987                 :            :  *     that requested. A return of NULL signals that the pad is end-of-stream.
     988                 :            :  *     Unref the buffer after use.
     989                 :            :  *
     990                 :            :  * Since: 0.10.18
     991                 :            :  */
     992                 :            : GstBuffer *
     993                 :          0 : gst_collect_pads_take_buffer (GstCollectPads * pads, GstCollectData * data,
     994                 :            :     guint size)
     995                 :            : {
     996                 :          0 :   GstBuffer *buffer = gst_collect_pads_read_buffer (pads, data, size);
     997                 :            : 
     998         [ #  # ]:          0 :   if (buffer) {
     999                 :          0 :     gst_collect_pads_flush (pads, data, GST_BUFFER_SIZE (buffer));
    1000                 :            :   }
    1001                 :          0 :   return buffer;
    1002                 :            : }
    1003                 :            : 
    1004                 :            : /**
    1005                 :            :  * gst_collect_pads_flush:
    1006                 :            :  * @pads: the collectspads to query
    1007                 :            :  * @data: the data to use
    1008                 :            :  * @size: the number of bytes to flush
    1009                 :            :  *
    1010                 :            :  * Flush @size bytes from the pad @data.
    1011                 :            :  *
    1012                 :            :  * This function should be called with @pads LOCK held, such as
    1013                 :            :  * in the callback.
    1014                 :            :  *
    1015                 :            :  * MT safe.
    1016                 :            :  *
    1017                 :            :  * Returns: The number of bytes flushed. This can be less than @size and
    1018                 :            :  * is 0 if the pad was end-of-stream.
    1019                 :            :  */
    1020                 :            : guint
    1021                 :          0 : gst_collect_pads_flush (GstCollectPads * pads, GstCollectData * data,
    1022                 :            :     guint size)
    1023                 :            : {
    1024                 :            :   guint flushsize;
    1025                 :            :   GstBuffer *buffer;
    1026                 :            : 
    1027         [ #  # ]:          0 :   g_return_val_if_fail (pads != NULL, 0);
    1028 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), 0);
         [ #  # ][ #  # ]
    1029         [ #  # ]:          0 :   g_return_val_if_fail (data != NULL, 0);
    1030                 :            : 
    1031                 :            :   /* no buffer, must be EOS */
    1032         [ #  # ]:          0 :   if ((buffer = data->buffer) == NULL)
    1033                 :          0 :     return 0;
    1034                 :            : 
    1035                 :            :   /* this is what we can flush at max */
    1036                 :          0 :   flushsize = MIN (size, GST_BUFFER_SIZE (buffer) - data->pos);
    1037                 :            : 
    1038                 :          0 :   data->pos += size;
    1039                 :            : 
    1040         [ #  # ]:          0 :   GST_LOG_OBJECT (pads, "Flushing %d bytes, requested %u", flushsize, size);
    1041                 :            : 
    1042         [ #  # ]:          0 :   if (data->pos >= GST_BUFFER_SIZE (buffer))
    1043                 :            :     /* _clear will also reset data->pos to 0 */
    1044                 :          0 :     gst_collect_pads_clear (pads, data);
    1045                 :            : 
    1046                 :          0 :   return flushsize;
    1047                 :            : }
    1048                 :            : 
    1049                 :            : /* see if pads were added or removed and update our stats. Any pad
    1050                 :            :  * added after releasing the PAD_LOCK will get collected in the next
    1051                 :            :  * round.
    1052                 :            :  *
    1053                 :            :  * We can do a quick check by checking the cookies, that get changed
    1054                 :            :  * whenever the pad list is updated.
    1055                 :            :  *
    1056                 :            :  * Must be called with LOCK.
    1057                 :            :  */
    1058                 :            : static void
    1059                 :          0 : gst_collect_pads_check_pads_unlocked (GstCollectPads * pads)
    1060                 :            : {
    1061         [ #  # ]:          0 :   GST_DEBUG ("stored cookie : %d, used_cookie:%d",
    1062                 :            :       pads->abidata.ABI.pad_cookie, pads->cookie);
    1063         [ #  # ]:          0 :   if (G_UNLIKELY (pads->abidata.ABI.pad_cookie != pads->cookie)) {
    1064                 :            :     GSList *collected;
    1065                 :            : 
    1066                 :            :     /* clear list and stats */
    1067                 :          0 :     g_slist_foreach (pads->data, (GFunc) unref_data, NULL);
    1068                 :          0 :     g_slist_free (pads->data);
    1069                 :          0 :     pads->data = NULL;
    1070                 :          0 :     pads->numpads = 0;
    1071                 :          0 :     pads->queuedpads = 0;
    1072                 :          0 :     pads->eospads = 0;
    1073                 :            : 
    1074                 :            :     /* loop over the master pad list */
    1075                 :          0 :     collected = pads->abidata.ABI.pad_list;
    1076 [ #  # ][ #  # ]:          0 :     for (; collected; collected = g_slist_next (collected)) {
    1077                 :            :       GstCollectData *data;
    1078                 :            : 
    1079                 :            :       /* update the stats */
    1080                 :          0 :       pads->numpads++;
    1081                 :          0 :       data = collected->data;
    1082                 :            : 
    1083         [ #  # ]:          0 :       if (G_LIKELY (!data->abidata.ABI.flushing)) {
    1084         [ #  # ]:          0 :         if (data->buffer)
    1085                 :          0 :           pads->queuedpads++;
    1086         [ #  # ]:          0 :         if (data->abidata.ABI.eos)
    1087                 :          0 :           pads->eospads++;
    1088                 :            :       }
    1089                 :            : 
    1090                 :            :       /* add to the list of pads to collect */
    1091                 :          0 :       ref_data (data);
    1092                 :          0 :       pads->data = g_slist_prepend (pads->data, data);
    1093                 :            :     }
    1094                 :            :     /* and update the cookie */
    1095                 :          0 :     pads->cookie = pads->abidata.ABI.pad_cookie;
    1096                 :            :   }
    1097                 :          0 : }
    1098                 :            : 
    1099                 :            : static inline void
    1100                 :          0 : gst_collect_pads_check_pads (GstCollectPads * pads)
    1101                 :            : {
    1102                 :            :   /* the master list and cookie are protected with the PAD_LOCK */
    1103                 :          0 :   GST_COLLECT_PADS_PAD_LOCK (pads);
    1104                 :          0 :   gst_collect_pads_check_pads_unlocked (pads);
    1105                 :          0 :   GST_COLLECT_PADS_PAD_UNLOCK (pads);
    1106                 :          0 : }
    1107                 :            : 
    1108                 :            : /* checks if all the pads are collected and call the collectfunction
    1109                 :            :  *
    1110                 :            :  * Should be called with LOCK.
    1111                 :            :  *
    1112                 :            :  * Returns: The #GstFlowReturn of collection.
    1113                 :            :  */
    1114                 :            : static GstFlowReturn
    1115                 :          0 : gst_collect_pads_check_collected (GstCollectPads * pads)
    1116                 :            : {
    1117                 :          0 :   GstFlowReturn flow_ret = GST_FLOW_OK;
    1118                 :            : 
    1119 [ #  # ][ #  # ]:          0 :   g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), GST_FLOW_ERROR);
         [ #  # ][ #  # ]
    1120         [ #  # ]:          0 :   g_return_val_if_fail (pads->func != NULL, GST_FLOW_NOT_SUPPORTED);
    1121                 :            : 
    1122                 :            :   /* check for new pads, update stats etc.. */
    1123                 :          0 :   gst_collect_pads_check_pads (pads);
    1124                 :            : 
    1125         [ #  # ]:          0 :   if (G_UNLIKELY (pads->eospads == pads->numpads)) {
    1126                 :            :     /* If all our pads are EOS just collect once to let the element
    1127                 :            :      * do its final EOS handling. */
    1128         [ #  # ]:          0 :     GST_DEBUG ("All active pads (%d) are EOS, calling %s",
    1129                 :            :         pads->numpads, GST_DEBUG_FUNCPTR_NAME (pads->func));
    1130                 :          0 :     flow_ret = pads->func (pads, pads->user_data);
    1131                 :            :   } else {
    1132                 :          0 :     gboolean collected = FALSE;
    1133                 :            : 
    1134                 :            :     /* We call the collected function as long as our condition matches.
    1135                 :            :      * FIXME: should we error out if the collect function did not pop anything ?
    1136                 :            :      * we can get a busy loop here if the element does not pop from the collect
    1137                 :            :      * function
    1138                 :            :      */
    1139         [ #  # ]:          0 :     while (((pads->queuedpads + pads->eospads) >= pads->numpads)) {
    1140         [ #  # ]:          0 :       GST_DEBUG ("All active pads (%d + %d >= %d) have data, calling %s",
    1141                 :            :           pads->queuedpads, pads->eospads, pads->numpads,
    1142                 :            :           GST_DEBUG_FUNCPTR_NAME (pads->func));
    1143                 :          0 :       flow_ret = pads->func (pads, pads->user_data);
    1144                 :          0 :       collected = TRUE;
    1145                 :            : 
    1146                 :            :       /* break on error */
    1147         [ #  # ]:          0 :       if (flow_ret != GST_FLOW_OK)
    1148                 :          0 :         break;
    1149                 :            :       /* Don't keep looping after telling the element EOS or flushing */
    1150         [ #  # ]:          0 :       if (pads->queuedpads == 0)
    1151                 :          0 :         break;
    1152                 :            :     }
    1153         [ #  # ]:          0 :     if (!collected)
    1154         [ #  # ]:          0 :       GST_DEBUG ("Not all active pads (%d) have data, continuing",
    1155                 :            :           pads->numpads);
    1156                 :            :   }
    1157                 :          0 :   return flow_ret;
    1158                 :            : }
    1159                 :            : 
    1160                 :            : static gboolean
    1161                 :          0 : gst_collect_pads_event (GstPad * pad, GstEvent * event)
    1162                 :            : {
    1163                 :            :   gboolean res;
    1164                 :            :   GstCollectData *data;
    1165                 :            :   GstCollectPads *pads;
    1166                 :            : 
    1167                 :            :   /* some magic to get the managing collect_pads */
    1168                 :          0 :   GST_OBJECT_LOCK (pad);
    1169                 :          0 :   data = (GstCollectData *) gst_pad_get_element_private (pad);
    1170         [ #  # ]:          0 :   if (G_UNLIKELY (data == NULL))
    1171                 :          0 :     goto pad_removed;
    1172                 :          0 :   ref_data (data);
    1173                 :          0 :   GST_OBJECT_UNLOCK (pad);
    1174                 :            : 
    1175                 :          0 :   res = TRUE;
    1176                 :            : 
    1177                 :          0 :   pads = data->collect;
    1178                 :            : 
    1179 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("Got %s event on pad %s:%s", GST_EVENT_TYPE_NAME (event),
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1180                 :            :       GST_DEBUG_PAD_NAME (data->pad));
    1181                 :            : 
    1182   [ #  #  #  #  :          0 :   switch (GST_EVENT_TYPE (event)) {
                      # ]
    1183                 :            :     case GST_EVENT_FLUSH_START:
    1184                 :            :     {
    1185                 :            :       /* forward event to unblock check_collected */
    1186                 :          0 :       gst_pad_event_default (pad, event);
    1187                 :            : 
    1188                 :            :       /* now unblock the chain function.
    1189                 :            :        * no cond per pad, so they all unblock,
    1190                 :            :        * non-flushing block again */
    1191                 :          0 :       GST_OBJECT_LOCK (pads);
    1192                 :          0 :       data->abidata.ABI.flushing = TRUE;
    1193                 :          0 :       gst_collect_pads_clear (pads, data);
    1194                 :          0 :       GST_OBJECT_UNLOCK (pads);
    1195                 :            : 
    1196                 :            :       /* event already cleaned up by forwarding */
    1197                 :          0 :       goto done;
    1198                 :            :     }
    1199                 :            :     case GST_EVENT_FLUSH_STOP:
    1200                 :            :     {
    1201                 :            :       /* flush the 1 buffer queue */
    1202                 :          0 :       GST_OBJECT_LOCK (pads);
    1203                 :          0 :       data->abidata.ABI.flushing = FALSE;
    1204                 :          0 :       gst_collect_pads_clear (pads, data);
    1205                 :            :       /* we need new segment info after the flush */
    1206                 :          0 :       gst_segment_init (&data->segment, GST_FORMAT_UNDEFINED);
    1207                 :          0 :       data->abidata.ABI.new_segment = FALSE;
    1208                 :            :       /* if the pad was EOS, remove the EOS flag and
    1209                 :            :        * decrement the number of eospads */
    1210         [ #  # ]:          0 :       if (G_UNLIKELY (data->abidata.ABI.eos == TRUE)) {
    1211                 :          0 :         pads->eospads--;
    1212                 :          0 :         data->abidata.ABI.eos = FALSE;
    1213                 :            :       }
    1214                 :            : 
    1215         [ #  # ]:          0 :       if (!gst_collect_pads_is_flushing (pads)) {
    1216                 :            :         /* forward event if all pads are no longer flushing */
    1217         [ #  # ]:          0 :         GST_DEBUG ("No more pads are flushing, forwarding FLUSH_STOP");
    1218                 :          0 :         GST_OBJECT_UNLOCK (pads);
    1219                 :          0 :         goto forward;
    1220                 :            :       }
    1221                 :          0 :       gst_event_unref (event);
    1222                 :          0 :       GST_OBJECT_UNLOCK (pads);
    1223                 :          0 :       goto done;
    1224                 :            :     }
    1225                 :            :     case GST_EVENT_EOS:
    1226                 :            :     {
    1227                 :          0 :       GST_OBJECT_LOCK (pads);
    1228                 :            :       /* if the pad was not EOS, make it EOS and so we
    1229                 :            :        * have one more eospad */
    1230         [ #  # ]:          0 :       if (G_LIKELY (data->abidata.ABI.eos == FALSE)) {
    1231                 :          0 :         data->abidata.ABI.eos = TRUE;
    1232                 :          0 :         pads->eospads++;
    1233                 :            :       }
    1234                 :            :       /* check if we need collecting anything, we ignore the
    1235                 :            :        * result. */
    1236                 :          0 :       gst_collect_pads_check_collected (pads);
    1237                 :          0 :       GST_OBJECT_UNLOCK (pads);
    1238                 :            : 
    1239                 :            :       /* We eat this event, element should do something
    1240                 :            :        * in the collected callback. */
    1241                 :          0 :       gst_event_unref (event);
    1242                 :          0 :       goto done;
    1243                 :            :     }
    1244                 :            :     case GST_EVENT_NEWSEGMENT:
    1245                 :            :     {
    1246                 :            :       gint64 start, stop, time;
    1247                 :            :       gdouble rate, arate;
    1248                 :            :       GstFormat format;
    1249                 :            :       gboolean update;
    1250                 :            : 
    1251                 :          0 :       gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
    1252                 :            :           &start, &stop, &time);
    1253                 :            : 
    1254 [ #  # ][ #  # ]:          0 :       GST_DEBUG_OBJECT (data->pad, "got newsegment, start %" GST_TIME_FORMAT
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
    1255                 :            :           ", stop %" GST_TIME_FORMAT, GST_TIME_ARGS (start),
    1256                 :            :           GST_TIME_ARGS (stop));
    1257                 :            : 
    1258                 :          0 :       gst_segment_set_newsegment_full (&data->segment, update, rate, arate,
    1259                 :            :           format, start, stop, time);
    1260                 :            : 
    1261                 :          0 :       data->abidata.ABI.new_segment = TRUE;
    1262                 :            : 
    1263                 :            :       /* we must not forward this event since multiple segments will be
    1264                 :            :        * accumulated and this is certainly not what we want. */
    1265                 :          0 :       gst_event_unref (event);
    1266                 :            :       /* FIXME: collect-pads based elements need to create their own newsegment
    1267                 :            :        * event (and only one really)
    1268                 :            :        * (a) make the segment part of the GstCollectData structure of each pad,
    1269                 :            :        * so you can just check that once you have a buffer queued on that pad,
    1270                 :            :        * (b) you can override a pad's event function with your own,
    1271                 :            :        * catch the newsegment event and then pass it on to the original
    1272                 :            :        * gstcollectpads event function
    1273                 :            :        * (that's what avimux does for something IIRC)
    1274                 :            :        * see #340060
    1275                 :            :        */
    1276                 :          0 :       goto done;
    1277                 :            :     }
    1278                 :            :     default:
    1279                 :            :       /* forward other events */
    1280                 :          0 :       goto forward;
    1281                 :            :   }
    1282                 :            : 
    1283                 :            : forward:
    1284         [ #  # ]:          0 :   GST_DEBUG_OBJECT (pads, "forward unhandled event: %s",
    1285                 :            :       GST_EVENT_TYPE_NAME (event));
    1286                 :          0 :   res = gst_pad_event_default (pad, event);
    1287                 :            : 
    1288                 :            : done:
    1289                 :          0 :   unref_data (data);
    1290                 :          0 :   return res;
    1291                 :            : 
    1292                 :            :   /* ERRORS */
    1293                 :            : pad_removed:
    1294                 :            :   {
    1295         [ #  # ]:          0 :     GST_DEBUG ("%s got removed from collectpads", GST_OBJECT_NAME (pad));
    1296                 :          0 :     GST_OBJECT_UNLOCK (pad);
    1297                 :          0 :     return FALSE;
    1298                 :            :   }
    1299                 :            : }
    1300                 :            : 
    1301                 :            : /* For each buffer we receive we check if our collected condition is reached
    1302                 :            :  * and if so we call the collected function. When this is done we check if
    1303                 :            :  * data has been unqueued. If data is still queued we wait holding the stream
    1304                 :            :  * lock to make sure no EOS event can happen while we are ready to be
    1305                 :            :  * collected
    1306                 :            :  */
    1307                 :            : static GstFlowReturn
    1308                 :          0 : gst_collect_pads_chain (GstPad * pad, GstBuffer * buffer)
    1309                 :            : {
    1310                 :            :   GstCollectData *data;
    1311                 :            :   GstCollectPads *pads;
    1312                 :            :   GstCollectPadsPrivate *priv;
    1313                 :            :   GstFlowReturn ret;
    1314                 :            : 
    1315 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("Got buffer for pad %s:%s", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1316                 :            : 
    1317                 :            :   /* some magic to get the managing collect_pads */
    1318                 :          0 :   GST_OBJECT_LOCK (pad);
    1319                 :          0 :   data = (GstCollectData *) gst_pad_get_element_private (pad);
    1320         [ #  # ]:          0 :   if (G_UNLIKELY (data == NULL))
    1321                 :          0 :     goto no_data;
    1322                 :          0 :   ref_data (data);
    1323                 :          0 :   GST_OBJECT_UNLOCK (pad);
    1324                 :            : 
    1325                 :          0 :   pads = data->collect;
    1326                 :          0 :   priv = pads->abidata.ABI.priv;
    1327                 :            : 
    1328                 :          0 :   GST_OBJECT_LOCK (pads);
    1329                 :            :   /* if not started, bail out */
    1330         [ #  # ]:          0 :   if (G_UNLIKELY (!pads->started))
    1331                 :          0 :     goto not_started;
    1332                 :            :   /* check if this pad is flushing */
    1333         [ #  # ]:          0 :   if (G_UNLIKELY (data->abidata.ABI.flushing))
    1334                 :          0 :     goto flushing;
    1335                 :            :   /* pad was EOS, we can refuse this data */
    1336         [ #  # ]:          0 :   if (G_UNLIKELY (data->abidata.ABI.eos))
    1337                 :          0 :     goto unexpected;
    1338                 :            : 
    1339                 :            :   /* see if we need to clip */
    1340         [ #  # ]:          0 :   if (priv->clipfunc) {
    1341                 :          0 :     buffer = priv->clipfunc (pads, data, buffer, priv->clipfunc_user_data);
    1342                 :            : 
    1343         [ #  # ]:          0 :     if (G_UNLIKELY (buffer == NULL))
    1344                 :          0 :       goto clipped;
    1345                 :            :   }
    1346                 :            : 
    1347 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("Queuing buffer %p for pad %s:%s", buffer,
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1348                 :            :       GST_DEBUG_PAD_NAME (pad));
    1349                 :            : 
    1350                 :            :   /* One more pad has data queued */
    1351                 :          0 :   pads->queuedpads++;
    1352                 :            :   /* take ownership of the buffer */
    1353         [ #  # ]:          0 :   if (data->buffer)
    1354                 :          0 :     gst_buffer_unref (data->buffer);
    1355                 :          0 :   data->buffer = buffer;
    1356                 :          0 :   buffer = NULL;
    1357                 :            : 
    1358                 :            :   /* update segment last position if in TIME */
    1359         [ #  # ]:          0 :   if (G_LIKELY (data->segment.format == GST_FORMAT_TIME)) {
    1360                 :          0 :     GstClockTime timestamp = GST_BUFFER_TIMESTAMP (data->buffer);
    1361                 :            : 
    1362         [ #  # ]:          0 :     if (GST_CLOCK_TIME_IS_VALID (timestamp))
    1363                 :          0 :       gst_segment_set_last_stop (&data->segment, GST_FORMAT_TIME, timestamp);
    1364                 :            :   }
    1365                 :            : 
    1366                 :            :   /* While we have data queued on this pad try to collect stuff */
    1367                 :            :   do {
    1368 [ #  # ][ #  # ]:          0 :     GST_DEBUG ("Pad %s:%s checking", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1369                 :            :     /* Check if our collected condition is matched and call the collected function
    1370                 :            :      * if it is */
    1371                 :          0 :     ret = gst_collect_pads_check_collected (pads);
    1372                 :            :     /* when an error occurs, we want to report this back to the caller ASAP
    1373                 :            :      * without having to block if the buffer was not popped */
    1374         [ #  # ]:          0 :     if (G_UNLIKELY (ret != GST_FLOW_OK))
    1375                 :          0 :       goto error;
    1376                 :            : 
    1377                 :            :     /* data was consumed, we can exit and accept new data */
    1378         [ #  # ]:          0 :     if (data->buffer == NULL)
    1379                 :          0 :       break;
    1380                 :            : 
    1381                 :            :     /* Check if we got removed in the mean time, FIXME, this is racy.
    1382                 :            :      * Between this check and the _WAIT, the pad could be removed which will
    1383                 :            :      * makes us hang in the _WAIT. */
    1384                 :          0 :     GST_OBJECT_LOCK (pad);
    1385         [ #  # ]:          0 :     if (G_UNLIKELY (gst_pad_get_element_private (pad) == NULL))
    1386                 :          0 :       goto pad_removed;
    1387                 :          0 :     GST_OBJECT_UNLOCK (pad);
    1388                 :            : 
    1389 [ #  # ][ #  # ]:          0 :     GST_DEBUG ("Pad %s:%s has a buffer queued, waiting",
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1390                 :            :         GST_DEBUG_PAD_NAME (pad));
    1391                 :            : 
    1392                 :            :     /* wait to be collected, this must happen from another thread triggered
    1393                 :            :      * by the _chain function of another pad. We release the lock so we
    1394                 :            :      * can get stopped or flushed as well. We can however not get EOS
    1395                 :            :      * because we still hold the STREAM_LOCK.
    1396                 :            :      */
    1397                 :          0 :     GST_COLLECT_PADS_WAIT (pads);
    1398                 :            : 
    1399 [ #  # ][ #  # ]:          0 :     GST_DEBUG ("Pad %s:%s resuming", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1400                 :            : 
    1401                 :            :     /* after a signal, we could be stopped */
    1402         [ #  # ]:          0 :     if (G_UNLIKELY (!pads->started))
    1403                 :          0 :       goto not_started;
    1404                 :            :     /* check if this pad is flushing */
    1405         [ #  # ]:          0 :     if (G_UNLIKELY (data->abidata.ABI.flushing))
    1406                 :          0 :       goto flushing;
    1407                 :            :   }
    1408         [ #  # ]:          0 :   while (data->buffer != NULL);
    1409                 :            : 
    1410                 :            : unlock_done:
    1411 [ #  # ][ #  # ]:          0 :   GST_DEBUG ("Pad %s:%s done", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1412                 :          0 :   GST_OBJECT_UNLOCK (pads);
    1413                 :          0 :   unref_data (data);
    1414         [ #  # ]:          0 :   if (buffer)
    1415                 :          0 :     gst_buffer_unref (buffer);
    1416                 :          0 :   return ret;
    1417                 :            : 
    1418                 :            : pad_removed:
    1419                 :            :   {
    1420         [ #  # ]:          0 :     GST_WARNING ("%s got removed from collectpads", GST_OBJECT_NAME (pad));
    1421                 :          0 :     GST_OBJECT_UNLOCK (pad);
    1422                 :          0 :     ret = GST_FLOW_NOT_LINKED;
    1423                 :          0 :     goto unlock_done;
    1424                 :            :   }
    1425                 :            :   /* ERRORS */
    1426                 :            : no_data:
    1427                 :            :   {
    1428         [ #  # ]:          0 :     GST_DEBUG ("%s got removed from collectpads", GST_OBJECT_NAME (pad));
    1429                 :          0 :     GST_OBJECT_UNLOCK (pad);
    1430                 :          0 :     gst_buffer_unref (buffer);
    1431                 :          0 :     return GST_FLOW_NOT_LINKED;
    1432                 :            :   }
    1433                 :            : not_started:
    1434                 :            :   {
    1435         [ #  # ]:          0 :     GST_DEBUG ("not started");
    1436                 :          0 :     gst_collect_pads_clear (pads, data);
    1437                 :          0 :     ret = GST_FLOW_WRONG_STATE;
    1438                 :          0 :     goto unlock_done;
    1439                 :            :   }
    1440                 :            : flushing:
    1441                 :            :   {
    1442 [ #  # ][ #  # ]:          0 :     GST_DEBUG ("pad %s:%s is flushing", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1443                 :          0 :     gst_collect_pads_clear (pads, data);
    1444                 :          0 :     ret = GST_FLOW_WRONG_STATE;
    1445                 :          0 :     goto unlock_done;
    1446                 :            :   }
    1447                 :            : unexpected:
    1448                 :            :   {
    1449                 :            :     /* we should not post an error for this, just inform upstream that
    1450                 :            :      * we don't expect anything anymore */
    1451 [ #  # ][ #  # ]:          0 :     GST_DEBUG ("pad %s:%s is eos", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1452                 :          0 :     ret = GST_FLOW_UNEXPECTED;
    1453                 :          0 :     goto unlock_done;
    1454                 :            :   }
    1455                 :            : clipped:
    1456                 :            :   {
    1457 [ #  # ][ #  # ]:          0 :     GST_DEBUG ("clipped buffer on pad %s:%s", GST_DEBUG_PAD_NAME (pad));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1458                 :          0 :     ret = GST_FLOW_OK;
    1459                 :          0 :     goto unlock_done;
    1460                 :            :   }
    1461                 :            : error:
    1462                 :            :   {
    1463                 :            :     /* we print the error, the element should post a reasonable error
    1464                 :            :      * message for fatal errors */
    1465         [ #  # ]:          0 :     GST_DEBUG ("collect failed, reason %d (%s)", ret, gst_flow_get_name (ret));
    1466                 :          0 :     gst_collect_pads_clear (pads, data);
    1467                 :          0 :     goto unlock_done;
    1468                 :            :   }
    1469                 :            : }

Generated by: LCOV version 1.9