From b64067f96110edccc73110a4ef4e6a7c6fac195d Mon Sep 17 00:00:00 2001 From: Sebastian Dröge Date: Fri, 27 Jan 2012 15:02:52 +0100 Subject: collectpads2: Move private fields from the public structs to private structs Fixes bug #668764. --- libs/gst/base/gstcollectpads2.c | 309 ++++++++++++++++++++++++---------------- libs/gst/base/gstcollectpads2.h | 42 +----- 2 files changed, 190 insertions(+), 161 deletions(-) diff --git a/libs/gst/base/gstcollectpads2.c b/libs/gst/base/gstcollectpads2.c index 932e3c903a..a2fdd6bc43 100644 --- a/libs/gst/base/gstcollectpads2.c +++ b/libs/gst/base/gstcollectpads2.c @@ -101,6 +101,47 @@ GST_DEBUG_CATEGORY_STATIC (collect_pads2_debug); #define parent_class gst_collect_pads2_parent_class G_DEFINE_TYPE (GstCollectPads2, gst_collect_pads2, GST_TYPE_OBJECT); +struct _GstCollectData2Private +{ + /* refcounting for struct, and destroy callback */ + GstCollectData2DestroyNotify destroy_notify; + gint refcount; +}; + +struct _GstCollectPads2Private +{ + /* with LOCK and/or STREAM_LOCK */ + gboolean started; + + /* with STREAM_LOCK */ + guint32 cookie; /* @data list cookie */ + guint numpads; /* number of pads in @data */ + guint queuedpads; /* number of pads with a buffer */ + guint eospads; /* number of pads that are EOS */ + GstClockTime earliest_time; /* Current earliest time */ + GstCollectData2 *earliest_data; /* Pad data for current earliest time */ + + /* with LOCK */ + GSList *pad_list; /* updated pad list */ + guint32 pad_cookie; /* updated cookie */ + + GstCollectPads2Function func; /* function and user_data for callback */ + gpointer user_data; + GstCollectPads2BufferFunction buffer_func; /* function and user_data for buffer callback */ + gpointer buffer_user_data; + GstCollectPads2CompareFunction compare_func; + gpointer compare_user_data; + GstCollectPads2EventFunction event_func; /* function and data for event callback */ + gpointer event_user_data; + GstCollectPads2ClipFunction clip_func; + gpointer clip_user_data; + + /* no other lock needed */ + GMutex *evt_lock; /* these make up sort of poor man's event signaling */ + GCond *evt_cond; + guint32 evt_cookie; +}; + static void gst_collect_pads2_clear (GstCollectPads2 * pads, GstCollectData2 * data); static GstFlowReturn gst_collect_pads2_chain (GstPad * pad, GstBuffer * buffer); @@ -121,15 +162,15 @@ static void unref_data (GstCollectData2 * data); * Alternative implementations are possible, e.g. some low-level re-implementing * of the 2 above locks to drop both of them atomically when going into _WAIT. */ -#define GST_COLLECT_PADS2_GET_EVT_COND(pads) (((GstCollectPads2 *)pads)->evt_cond) -#define GST_COLLECT_PADS2_GET_EVT_LOCK(pads) (((GstCollectPads2 *)pads)->evt_lock) +#define GST_COLLECT_PADS2_GET_EVT_COND(pads) (((GstCollectPads2 *)pads)->priv->evt_cond) +#define GST_COLLECT_PADS2_GET_EVT_LOCK(pads) (((GstCollectPads2 *)pads)->priv->evt_lock) #define GST_COLLECT_PADS2_EVT_WAIT(pads, cookie) G_STMT_START { \ g_mutex_lock (GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ /* should work unless a lot of event'ing and thread starvation */\ - while (cookie == ((GstCollectPads2 *) pads)->evt_cookie) \ + while (cookie == ((GstCollectPads2 *) pads)->priv->evt_cookie) \ g_cond_wait (GST_COLLECT_PADS2_GET_EVT_COND (pads), \ GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ - cookie = ((GstCollectPads2 *) pads)->evt_cookie; \ + cookie = ((GstCollectPads2 *) pads)->priv->evt_cookie; \ g_mutex_unlock (GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ } G_STMT_END #define GST_COLLECT_PADS2_EVT_WAIT_TIMED(pads, cookie, timeout) G_STMT_START { \ @@ -140,22 +181,22 @@ static void unref_data (GstCollectData2 * data); \ g_mutex_lock (GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ /* should work unless a lot of event'ing and thread starvation */\ - while (cookie == ((GstCollectPads2 *) pads)->evt_cookie) \ + while (cookie == ((GstCollectPads2 *) pads)->priv->evt_cookie) \ g_cond_timed_wait (GST_COLLECT_PADS2_GET_EVT_COND (pads), \ GST_COLLECT_PADS2_GET_EVT_LOCK (pads), &tv); \ - cookie = ((GstCollectPads2 *) pads)->evt_cookie; \ + cookie = ((GstCollectPads2 *) pads)->priv->evt_cookie; \ g_mutex_unlock (GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ } G_STMT_END #define GST_COLLECT_PADS2_EVT_BROADCAST(pads) G_STMT_START { \ g_mutex_lock (GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ /* never mind wrap-around */ \ - ++(((GstCollectPads2 *) pads)->evt_cookie); \ + ++(((GstCollectPads2 *) pads)->priv->evt_cookie); \ g_cond_broadcast (GST_COLLECT_PADS2_GET_EVT_COND (pads)); \ g_mutex_unlock (GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ } G_STMT_END #define GST_COLLECT_PADS2_EVT_INIT(cookie) G_STMT_START { \ g_mutex_lock (GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ - cookie = ((GstCollectPads2 *) pads)->evt_cookie; \ + cookie = ((GstCollectPads2 *) pads)->priv->evt_cookie; \ g_mutex_unlock (GST_COLLECT_PADS2_GET_EVT_LOCK (pads)); \ } G_STMT_END @@ -164,6 +205,8 @@ gst_collect_pads2_class_init (GstCollectPads2Class * klass) { GObjectClass *gobject_class = (GObjectClass *) klass; + g_type_class_add_private (klass, sizeof (GstCollectPads2Private)); + GST_DEBUG_CATEGORY_INIT (collect_pads2_debug, "collectpads2", 0, "GstCollectPads2"); @@ -173,36 +216,40 @@ gst_collect_pads2_class_init (GstCollectPads2Class * klass) static void gst_collect_pads2_init (GstCollectPads2 * pads) { + pads->priv = + G_TYPE_INSTANCE_GET_PRIVATE (pads, GST_TYPE_COLLECT_PADS2, + GstCollectPads2Private); + pads->data = NULL; - pads->cookie = 0; - pads->numpads = 0; - pads->queuedpads = 0; - pads->eospads = 0; - pads->started = FALSE; + pads->priv->cookie = 0; + pads->priv->numpads = 0; + pads->priv->queuedpads = 0; + pads->priv->eospads = 0; + pads->priv->started = FALSE; g_static_rec_mutex_init (&pads->stream_lock); - pads->func = gst_collect_pads2_default_collected; - pads->user_data = NULL; - pads->event_func = NULL; - pads->event_user_data = NULL; + pads->priv->func = gst_collect_pads2_default_collected; + pads->priv->user_data = NULL; + pads->priv->event_func = NULL; + pads->priv->event_user_data = NULL; /* members for default muxing */ - pads->buffer_func = NULL; - pads->buffer_user_data = NULL; - pads->compare_func = gst_collect_pads2_default_compare_func; - pads->compare_user_data = NULL; - pads->earliest_data = NULL; - pads->earliest_time = GST_CLOCK_TIME_NONE; + pads->priv->buffer_func = NULL; + pads->priv->buffer_user_data = NULL; + pads->priv->compare_func = gst_collect_pads2_default_compare_func; + pads->priv->compare_user_data = NULL; + pads->priv->earliest_data = NULL; + pads->priv->earliest_time = GST_CLOCK_TIME_NONE; /* members to manage the pad list */ - pads->pad_cookie = 0; - pads->pad_list = NULL; + pads->priv->pad_cookie = 0; + pads->priv->pad_list = NULL; /* members for event */ - pads->evt_lock = g_mutex_new (); - pads->evt_cond = g_cond_new (); - pads->evt_cookie = 0; + pads->priv->evt_lock = g_mutex_new (); + pads->priv->evt_cond = g_cond_new (); + pads->priv->evt_cookie = 0; } static void @@ -214,14 +261,14 @@ gst_collect_pads2_finalize (GObject * object) g_static_rec_mutex_free (&pads->stream_lock); - g_cond_free (pads->evt_cond); - g_mutex_free (pads->evt_lock); + g_cond_free (pads->priv->evt_cond); + g_mutex_free (pads->priv->evt_lock); /* Remove pads and free pads list */ - g_slist_foreach (pads->pad_list, (GFunc) unref_data, NULL); + g_slist_foreach (pads->priv->pad_list, (GFunc) unref_data, NULL); g_slist_foreach (pads->data, (GFunc) unref_data, NULL); g_slist_free (pads->data); - g_slist_free (pads->pad_list); + g_slist_free (pads->priv->pad_list); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -252,8 +299,8 @@ static void gst_collect_pads2_set_buffer_function_locked (GstCollectPads2 * pads, GstCollectPads2BufferFunction func, gpointer user_data) { - pads->buffer_func = func; - pads->buffer_user_data = user_data; + pads->priv->buffer_func = func; + pads->priv->buffer_user_data = user_data; } /** @@ -305,8 +352,8 @@ gst_collect_pads2_set_compare_function (GstCollectPads2 * pads, g_return_if_fail (GST_IS_COLLECT_PADS2 (pads)); GST_OBJECT_LOCK (pads); - pads->compare_func = func; - pads->compare_user_data = user_data; + pads->priv->compare_func = func; + pads->priv->compare_user_data = user_data; GST_OBJECT_UNLOCK (pads); } @@ -338,8 +385,8 @@ gst_collect_pads2_set_function (GstCollectPads2 * pads, g_return_if_fail (GST_IS_COLLECT_PADS2 (pads)); GST_OBJECT_LOCK (pads); - pads->func = func; - pads->user_data = user_data; + pads->priv->func = func; + pads->priv->user_data = user_data; gst_collect_pads2_set_buffer_function_locked (pads, NULL, NULL); GST_OBJECT_UNLOCK (pads); } @@ -349,25 +396,26 @@ ref_data (GstCollectData2 * data) { g_assert (data != NULL); - g_atomic_int_inc (&(data->refcount)); + g_atomic_int_inc (&(data->priv->refcount)); } static void unref_data (GstCollectData2 * data) { g_assert (data != NULL); - g_assert (data->refcount > 0); + g_assert (data->priv->refcount > 0); - if (!g_atomic_int_dec_and_test (&(data->refcount))) + if (!g_atomic_int_dec_and_test (&(data->priv->refcount))) return; - if (data->destroy_notify) - data->destroy_notify (data); + if (data->priv->destroy_notify) + data->priv->destroy_notify (data); g_object_unref (data->pad); if (data->buffer) { gst_buffer_unref (data->buffer); } + g_free (data->priv); g_free (data); } @@ -396,8 +444,8 @@ gst_collect_pads2_set_event_function (GstCollectPads2 * pads, g_return_if_fail (GST_IS_COLLECT_PADS2 (pads)); GST_OBJECT_LOCK (pads); - pads->event_func = func; - pads->event_user_data = user_data; + pads->priv->event_func = func; + pads->priv->event_user_data = user_data; GST_OBJECT_UNLOCK (pads); } @@ -419,8 +467,8 @@ gst_collect_pads2_set_clip_function (GstCollectPads2 * pads, g_return_if_fail (pads != NULL); g_return_if_fail (GST_IS_COLLECT_PADS2 (pads)); - pads->clip_func = clipfunc; - pads->clip_user_data = user_data; + pads->priv->clip_func = clipfunc; + pads->priv->clip_user_data = user_data; } /** @@ -511,6 +559,7 @@ gst_collect_pads2_add_pad_full (GstCollectPads2 * pads, GstPad * pad, GST_DEBUG_OBJECT (pads, "adding pad %s:%s", GST_DEBUG_PAD_NAME (pad)); data = g_malloc0 (size); + data->priv = g_new0 (GstCollectData2Private, 1); data->collect = pads; data->pad = gst_object_ref (pad); data->buffer = NULL; @@ -518,28 +567,28 @@ gst_collect_pads2_add_pad_full (GstCollectPads2 * pads, GstPad * pad, gst_segment_init (&data->segment, GST_FORMAT_UNDEFINED); data->state = GST_COLLECT_PADS2_STATE_WAITING; data->state |= lock ? GST_COLLECT_PADS2_STATE_LOCKED : 0; - data->refcount = 1; - data->destroy_notify = destroy_notify; + data->priv->refcount = 1; + data->priv->destroy_notify = destroy_notify; GST_OBJECT_LOCK (pads); GST_OBJECT_LOCK (pad); gst_pad_set_element_private (pad, data); GST_OBJECT_UNLOCK (pad); - pads->pad_list = g_slist_append (pads->pad_list, data); + pads->priv->pad_list = g_slist_append (pads->priv->pad_list, data); gst_pad_set_chain_function (pad, GST_DEBUG_FUNCPTR (gst_collect_pads2_chain)); gst_pad_set_event_function (pad, GST_DEBUG_FUNCPTR (gst_collect_pads2_event)); /* backward compat, also add to data if stopped, so that the element already * has this in the public data list before going PAUSED (typically) * this can only be done when we are stopped because we don't take the * STREAM_LOCK to protect the pads->data list. */ - if (!pads->started) { + if (!pads->priv->started) { pads->data = g_slist_append (pads->data, data); ref_data (data); } /* activate the pad when needed */ - if (pads->started) + if (pads->priv->started) gst_pad_set_active (pad, TRUE); - pads->pad_cookie++; + pads->priv->pad_cookie++; GST_OBJECT_UNLOCK (pads); return data; @@ -584,7 +633,8 @@ gst_collect_pads2_remove_pad (GstCollectPads2 * pads, GstPad * pad) GST_DEBUG_OBJECT (pads, "removing pad %s:%s", GST_DEBUG_PAD_NAME (pad)); GST_OBJECT_LOCK (pads); - list = g_slist_find_custom (pads->pad_list, pad, (GCompareFunc) find_pad); + list = + g_slist_find_custom (pads->priv->pad_list, pad, (GCompareFunc) find_pad); if (!list) goto unknown_pad; @@ -603,7 +653,7 @@ gst_collect_pads2_remove_pad (GstCollectPads2 * pads, GstPad * pad) /* backward compat, also remove from data if stopped, note that this function * can only be called when we are stopped because we don't take the * STREAM_LOCK to protect the pads->data list. */ - if (!pads->started) { + if (!pads->priv->started) { GSList *dlist; dlist = g_slist_find_custom (pads->data, pad, (GCompareFunc) find_pad); @@ -615,14 +665,14 @@ gst_collect_pads2_remove_pad (GstCollectPads2 * pads, GstPad * pad) } } /* remove from the pad list */ - pads->pad_list = g_slist_delete_link (pads->pad_list, list); - pads->pad_cookie++; + pads->priv->pad_list = g_slist_delete_link (pads->priv->pad_list, list); + pads->priv->pad_cookie++; /* signal waiters because something changed */ GST_COLLECT_PADS2_EVT_BROADCAST (pads); /* deactivate the pad when needed */ - if (!pads->started) + if (!pads->priv->started) gst_pad_set_active (pad, FALSE); /* clean and free the collect data */ @@ -811,7 +861,7 @@ gst_collect_pads2_start (GstCollectPads2 * pads) GST_OBJECT_LOCK (pads); /* loop over the master pad list and reset the segment */ - collected = pads->pad_list; + collected = pads->priv->pad_list; for (; collected; collected = g_slist_next (collected)) { GstCollectData2 *data; @@ -822,7 +872,7 @@ gst_collect_pads2_start (GstCollectPads2 * pads) gst_collect_pads2_set_flushing_unlocked (pads, FALSE); /* Start collect pads */ - pads->started = TRUE; + pads->priv->started = TRUE; GST_OBJECT_UNLOCK (pads); GST_COLLECT_PADS2_STREAM_UNLOCK (pads); } @@ -856,12 +906,12 @@ gst_collect_pads2_stop (GstCollectPads2 * pads) gst_collect_pads2_set_flushing_unlocked (pads, TRUE); /* Stop collect pads */ - pads->started = FALSE; - pads->eospads = 0; - pads->queuedpads = 0; + pads->priv->started = FALSE; + pads->priv->eospads = 0; + pads->priv->queuedpads = 0; /* loop over the master pad list and flush buffers */ - collected = pads->pad_list; + collected = pads->priv->pad_list; for (; collected; collected = g_slist_next (collected)) { GstCollectData2 *data; GstBuffer **buffer_p; @@ -875,10 +925,10 @@ gst_collect_pads2_stop (GstCollectPads2 * pads) GST_COLLECT_PADS2_STATE_UNSET (data, GST_COLLECT_PADS2_STATE_EOS); } - if (pads->earliest_data) - unref_data (pads->earliest_data); - pads->earliest_data = NULL; - pads->earliest_time = GST_CLOCK_TIME_NONE; + if (pads->priv->earliest_data) + unref_data (pads->priv->earliest_data); + pads->priv->earliest_data = NULL; + pads->priv->earliest_time = GST_CLOCK_TIME_NONE; GST_OBJECT_UNLOCK (pads); /* Wake them up so they can end the chain functions. */ @@ -951,7 +1001,7 @@ gst_collect_pads2_pop (GstCollectPads2 * pads, GstCollectData2 * data) data->pos = 0; /* one less pad with queued data now */ if (GST_COLLECT_PADS2_STATE_IS_SET (data, GST_COLLECT_PADS2_STATE_WAITING)) - pads->queuedpads--; + pads->priv->queuedpads--; } GST_COLLECT_PADS2_EVT_BROADCAST (pads); @@ -1247,9 +1297,9 @@ gst_collect_pads2_set_waiting (GstCollectPads2 * pads, GstCollectData2 * data, if (!data->buffer && !GST_COLLECT_PADS2_STATE_IS_SET (data, GST_COLLECT_PADS2_STATE_EOS)) { if (waiting) - pads->queuedpads--; + pads->priv->queuedpads--; else - pads->queuedpads++; + pads->priv->queuedpads++; } /* signal waiters because something changed */ @@ -1271,34 +1321,34 @@ gst_collect_pads2_check_pads (GstCollectPads2 * pads) { /* the master list and cookie are protected with LOCK */ GST_OBJECT_LOCK (pads); - if (G_UNLIKELY (pads->pad_cookie != pads->cookie)) { + if (G_UNLIKELY (pads->priv->pad_cookie != pads->priv->cookie)) { GSList *collected; /* clear list and stats */ g_slist_foreach (pads->data, (GFunc) unref_data, NULL); g_slist_free (pads->data); pads->data = NULL; - pads->numpads = 0; - pads->queuedpads = 0; - pads->eospads = 0; - if (pads->earliest_data) - unref_data (pads->earliest_data); - pads->earliest_data = NULL; - pads->earliest_time = GST_CLOCK_TIME_NONE; + pads->priv->numpads = 0; + pads->priv->queuedpads = 0; + pads->priv->eospads = 0; + if (pads->priv->earliest_data) + unref_data (pads->priv->earliest_data); + pads->priv->earliest_data = NULL; + pads->priv->earliest_time = GST_CLOCK_TIME_NONE; /* loop over the master pad list */ - collected = pads->pad_list; + collected = pads->priv->pad_list; for (; collected; collected = g_slist_next (collected)) { GstCollectData2 *data; /* update the stats */ - pads->numpads++; + pads->priv->numpads++; data = collected->data; if (GST_COLLECT_PADS2_STATE_IS_SET (data, GST_COLLECT_PADS2_STATE_EOS)) - pads->eospads++; + pads->priv->eospads++; else if (data->buffer || !GST_COLLECT_PADS2_STATE_IS_SET (data, GST_COLLECT_PADS2_STATE_WAITING)) - pads->queuedpads++; + pads->priv->queuedpads++; /* add to the list of pads to collect */ ref_data (data); @@ -1306,7 +1356,7 @@ gst_collect_pads2_check_pads (GstCollectPads2 * pads) pads->data = g_slist_append (pads->data, data); } /* and update the cookie */ - pads->cookie = pads->pad_cookie; + pads->priv->cookie = pads->priv->pad_cookie; } GST_OBJECT_UNLOCK (pads); } @@ -1327,29 +1377,31 @@ gst_collect_pads2_check_collected (GstCollectPads2 * pads) g_return_val_if_fail (GST_IS_COLLECT_PADS2 (pads), GST_FLOW_ERROR); GST_OBJECT_LOCK (pads); - func = pads->func; - user_data = pads->user_data; + func = pads->priv->func; + user_data = pads->priv->user_data; GST_OBJECT_UNLOCK (pads); - g_return_val_if_fail (pads->func != NULL, GST_FLOW_NOT_SUPPORTED); + g_return_val_if_fail (pads->priv->func != NULL, GST_FLOW_NOT_SUPPORTED); /* check for new pads, update stats etc.. */ gst_collect_pads2_check_pads (pads); - if (G_UNLIKELY (pads->eospads == pads->numpads)) { + if (G_UNLIKELY (pads->priv->eospads == pads->priv->numpads)) { /* If all our pads are EOS just collect once to let the element * do its final EOS handling. */ GST_DEBUG_OBJECT (pads, "All active pads (%d) are EOS, calling %s", - pads->numpads, GST_DEBUG_FUNCPTR_NAME (func)); + pads->priv->numpads, GST_DEBUG_FUNCPTR_NAME (func)); flow_ret = func (pads, user_data); } else { gboolean collected = FALSE; /* We call the collected function as long as our condition matches. */ - while (((pads->queuedpads + pads->eospads) >= pads->numpads)) { - GST_DEBUG_OBJECT (pads, "All active pads (%d + %d >= %d) have data, " - "calling %s", pads->queuedpads, pads->eospads, pads->numpads, + while (((pads->priv->queuedpads + pads->priv->eospads) >= + pads->priv->numpads)) { + GST_DEBUG_OBJECT (pads, + "All active pads (%d + %d >= %d) have data, " "calling %s", + pads->priv->queuedpads, pads->priv->eospads, pads->priv->numpads, GST_DEBUG_FUNCPTR_NAME (func)); flow_ret = func (pads, user_data); @@ -1359,12 +1411,12 @@ gst_collect_pads2_check_collected (GstCollectPads2 * pads) if (flow_ret != GST_FLOW_OK) break; /* Don't keep looping after telling the element EOS or flushing */ - if (pads->queuedpads == 0) + if (pads->priv->queuedpads == 0) break; } if (!collected) GST_DEBUG_OBJECT (pads, "Not all active pads (%d) have data, continuing", - pads->numpads); + pads->priv->numpads); } return flow_ret; } @@ -1392,7 +1444,7 @@ gst_collect_pads2_recalculate_waiting (GstCollectPads2 * pads) gboolean result = FALSE; /* If earliest time is not known, there is nothing to do. */ - if (pads->earliest_data == NULL) + if (pads->priv->earliest_data == NULL) return FALSE; for (collected = pads->data; collected; collected = g_slist_next (collected)) { @@ -1410,8 +1462,9 @@ gst_collect_pads2_recalculate_waiting (GstCollectPads2 * pads) } /* check if the waiting state should be changed */ - cmp_res = pads->compare_func (pads, data, data->segment.start, - pads->earliest_data, pads->earliest_time, pads->compare_user_data); + cmp_res = pads->priv->compare_func (pads, data, data->segment.start, + pads->priv->earliest_data, pads->priv->earliest_time, + pads->priv->compare_user_data); if (cmp_res > 0) /* stop waiting */ gst_collect_pads2_set_waiting (pads, data, FALSE); @@ -1463,8 +1516,8 @@ gst_collect_pads2_find_best_pad (GstCollectPads2 * pads, if (buffer != NULL) { timestamp = GST_BUFFER_TIMESTAMP (buffer); gst_buffer_unref (buffer); - if (best == NULL || pads->compare_func (pads, data, timestamp, - best, best_time, pads->compare_user_data) < 0) { + if (best == NULL || pads->priv->compare_func (pads, data, timestamp, + best, best_time, pads->priv->compare_user_data) < 0) { best = data; best_time = timestamp; } @@ -1489,12 +1542,12 @@ gst_collect_pads2_find_best_pad (GstCollectPads2 * pads, static gboolean gst_collect_pads2_recalculate_full (GstCollectPads2 * pads) { - if (pads->earliest_data) - unref_data (pads->earliest_data); - gst_collect_pads2_find_best_pad (pads, &pads->earliest_data, - &pads->earliest_time); - if (pads->earliest_data) - ref_data (pads->earliest_data); + if (pads->priv->earliest_data) + unref_data (pads->priv->earliest_data); + gst_collect_pads2_find_best_pad (pads, &pads->priv->earliest_data, + &pads->priv->earliest_time); + if (pads->priv->earliest_data) + ref_data (pads->priv->earliest_data); return gst_collect_pads2_recalculate_waiting (pads); } @@ -1515,8 +1568,8 @@ gst_collect_pads2_default_collected (GstCollectPads2 * pads, gpointer user_data) g_return_val_if_fail (GST_IS_COLLECT_PADS2 (pads), GST_FLOW_ERROR); GST_OBJECT_LOCK (pads); - func = pads->buffer_func; - buffer_user_data = pads->buffer_user_data; + func = pads->priv->buffer_func; + buffer_user_data = pads->priv->buffer_user_data; GST_OBJECT_UNLOCK (pads); g_return_val_if_fail (func != NULL, GST_FLOW_NOT_SUPPORTED); @@ -1530,7 +1583,7 @@ gst_collect_pads2_default_collected (GstCollectPads2 * pads, gpointer user_data) goto done; } - best = pads->earliest_data; + best = pads->priv->earliest_data; /* No data collected means EOS. */ if (G_UNLIKELY (best == NULL)) { @@ -1613,9 +1666,9 @@ gst_collect_pads2_event (GstPad * pad, GstEvent * event) GST_DEBUG_PAD_NAME (data->pad)); GST_OBJECT_LOCK (pads); - event_func = pads->event_func; - event_user_data = pads->event_user_data; - buffer_func = pads->buffer_func; + event_func = pads->priv->event_func; + event_user_data = pads->priv->event_user_data; + buffer_func = pads->priv->buffer_func; GST_OBJECT_UNLOCK (pads); switch (GST_EVENT_TYPE (event)) { @@ -1639,10 +1692,10 @@ gst_collect_pads2_event (GstPad * pad, GstEvent * event) /* restore to initial state */ gst_collect_pads2_set_waiting (pads, data, TRUE); /* if the current pad is affected, reset state, recalculate later */ - if (pads->earliest_data == data) { + if (pads->priv->earliest_data == data) { unref_data (data); - pads->earliest_data = NULL; - pads->earliest_time = GST_CLOCK_TIME_NONE; + pads->priv->earliest_data = NULL; + pads->priv->earliest_time = GST_CLOCK_TIME_NONE; } } @@ -1667,8 +1720,8 @@ gst_collect_pads2_event (GstPad * pad, GstEvent * event) GST_COLLECT_PADS2_STATE_EOS))) { if (!GST_COLLECT_PADS2_STATE_IS_SET (data, GST_COLLECT_PADS2_STATE_WAITING)) - pads->queuedpads++; - pads->eospads--; + pads->priv->queuedpads++; + pads->priv->eospads--; GST_COLLECT_PADS2_STATE_UNSET (data, GST_COLLECT_PADS2_STATE_EOS); } GST_COLLECT_PADS2_STREAM_UNLOCK (pads); @@ -1686,8 +1739,8 @@ gst_collect_pads2_event (GstPad * pad, GstEvent * event) GST_COLLECT_PADS2_STATE_SET (data, GST_COLLECT_PADS2_STATE_EOS); if (!GST_COLLECT_PADS2_STATE_IS_SET (data, GST_COLLECT_PADS2_STATE_WAITING)) - pads->queuedpads--; - pads->eospads++; + pads->priv->queuedpads--; + pads->priv->eospads++; } /* check if we need collecting anything, we ignore the result. */ gst_collect_pads2_check_collected (pads); @@ -1730,14 +1783,16 @@ gst_collect_pads2_event (GstPad * pad, GstEvent * event) /* If oldest time is not known, or current pad got newsegment; * recalculate the state */ - if (!pads->earliest_data || pads->earliest_data == data) { + if (!pads->priv->earliest_data || pads->priv->earliest_data == data) { gst_collect_pads2_recalculate_full (pads); goto newsegment_done; } /* Check if the waiting state of the pad should change. */ - cmp_res = pads->compare_func (pads, data, start, pads->earliest_data, - pads->earliest_time, pads->compare_user_data); + cmp_res = + pads->priv->compare_func (pads, data, start, + pads->priv->earliest_data, pads->priv->earliest_time, + pads->priv->compare_user_data); if (cmp_res > 0) /* Stop waiting */ @@ -1824,7 +1879,7 @@ gst_collect_pads2_chain (GstPad * pad, GstBuffer * buffer) GST_COLLECT_PADS2_STREAM_LOCK (pads); /* if not started, bail out */ - if (G_UNLIKELY (!pads->started)) + if (G_UNLIKELY (!pads->priv->started)) goto not_started; /* check if this pad is flushing */ if (G_UNLIKELY (GST_COLLECT_PADS2_STATE_IS_SET (data, @@ -1836,9 +1891,11 @@ gst_collect_pads2_chain (GstPad * pad, GstBuffer * buffer) goto unexpected; /* see if we need to clip */ - if (pads->clip_func) { + if (pads->priv->clip_func) { GstBuffer *outbuf = NULL; - ret = pads->clip_func (pads, data, buffer, &outbuf, pads->clip_user_data); + ret = + pads->priv->clip_func (pads, data, buffer, &outbuf, + pads->priv->clip_user_data); buffer = outbuf; if (G_UNLIKELY (outbuf == NULL)) @@ -1855,7 +1912,7 @@ gst_collect_pads2_chain (GstPad * pad, GstBuffer * buffer) /* One more pad has data queued */ if (GST_COLLECT_PADS2_STATE_IS_SET (data, GST_COLLECT_PADS2_STATE_WAITING)) - pads->queuedpads++; + pads->priv->queuedpads++; buffer_p = &data->buffer; gst_buffer_replace (buffer_p, buffer); @@ -1912,7 +1969,7 @@ gst_collect_pads2_chain (GstPad * pad, GstBuffer * buffer) GST_DEBUG_OBJECT (pads, "Pad %s:%s resuming", GST_DEBUG_PAD_NAME (pad)); /* after a signal, we could be stopped */ - if (G_UNLIKELY (!pads->started)) + if (G_UNLIKELY (!pads->priv->started)) goto not_started; /* check if this pad is flushing */ if (G_UNLIKELY (GST_COLLECT_PADS2_STATE_IS_SET (data, diff --git a/libs/gst/base/gstcollectpads2.h b/libs/gst/base/gstcollectpads2.h index 208b547dc8..03414e9ab0 100644 --- a/libs/gst/base/gstcollectpads2.h +++ b/libs/gst/base/gstcollectpads2.h @@ -35,7 +35,9 @@ G_BEGIN_DECLS #define GST_IS_COLLECT_PADS2_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_COLLECT_PADS2)) typedef struct _GstCollectData2 GstCollectData2; +typedef struct _GstCollectData2Private GstCollectData2Private; typedef struct _GstCollectPads2 GstCollectPads2; +typedef struct _GstCollectPads2Private GstCollectPads2Private; typedef struct _GstCollectPads2Class GstCollectPads2Class; /** @@ -139,9 +141,7 @@ struct _GstCollectData2 * eos, flushing, new_segment, waiting */ GstCollectPads2StateFlags state; - /* refcounting for struct, and destroy callback */ - GstCollectData2DestroyNotify destroy_notify; - gint refcount; + GstCollectData2Private *priv; gpointer _gst_reserved[GST_PADDING]; }; @@ -287,38 +287,10 @@ struct _GstCollectPads2 { /*< private >*/ GStaticRecMutex stream_lock; /* used to serialize collection among several streams */ - /* with LOCK and/or STREAM_LOCK*/ - gboolean started; - - /* with STREAM_LOCK */ - guint32 cookie; /* @data list cookie */ - guint numpads; /* number of pads in @data */ - guint queuedpads; /* number of pads with a buffer */ - guint eospads; /* number of pads that are EOS */ - GstClockTime earliest_time; /* Current earliest time */ - GstCollectData2 *earliest_data; /* Pad data for current earliest time */ - - /* with LOCK */ - GSList *pad_list; /* updated pad list */ - guint32 pad_cookie; /* updated cookie */ - - GstCollectPads2Function func; /* function and user_data for callback */ - gpointer user_data; - GstCollectPads2BufferFunction buffer_func; /* function and user_data for buffer callback */ - gpointer buffer_user_data; - GstCollectPads2CompareFunction compare_func; - gpointer compare_user_data; - GstCollectPads2EventFunction event_func; /* function and data for event callback */ - gpointer event_user_data; - GstCollectPads2ClipFunction clip_func; - gpointer clip_user_data; - - /* no other lock needed */ - GMutex *evt_lock; /* these make up sort of poor man's event signaling */ - GCond *evt_cond; - guint32 evt_cookie; - - gpointer _gst_reserved[GST_PADDING + 0]; + + GstCollectPads2Private *priv; + + gpointer _gst_reserved[GST_PADDING]; }; -- cgit v1.2.3