gstreamer的collectpad源码分析

1. 背景：

        gstreamer的collectpad是一类特殊的pad，这类pad工作于收集模式，用于管理控制若干个pad组成的pad集合的数据同步处理。大部分的合成器（muxer）均使用collectpad来收集音视频数据，并根据可重载的收集条件判断函数对不同pad之间的数据进行处理（或同步）。

        由于collectpad中大部分处理函数均可重载（set_func），因此本文只讨论默认的处理函数。

2. 默认流程：

        collectpad的简单流程如下图：

        不同的pad工作与不同的线程中，当某一个pad有数据到来时，会对所有pad进行判断，看看是否可以满足收集条件，如果满足收集条件就向对应的element推送数据。如果不满足收集条件，就会将该线程挂起，等待其他线程的数据。

        当某个pad处于挂起时，其他pad收到数据后，一样会对收集条件进行判断，如果满足条件，会将所有pad的数据推送至element，同时广播条件变量，唤醒所有挂起中的其他pad（线程）。

        简单的函数调用关系如下：

3. 数据结构：

        数据结构如下：一个_GstCollectPads中维护了一个_GstCollectData的链表，每个pad对应一个_GstCollectData，其中记录了pad中的数据的时间戳，buffer，已经对应pad的状态（如锁、等待等标志位），GstCollectPadsPrivate中则记录了collectpad中注册的各种事件回调函数，这里的回调函数都有接口可以进行重载。此外，GstCollectPadsPrivate还维护了线程间同步用的锁和条件变量。

/** * GstCollectPads: * @data: (element-type GstBase.CollectData): #GList of #GstCollectData managed *   by this #GstCollectPads. * * Collectpads object. */struct _GstCollectPads {  /* 基类。  */  GstObject      object;  /*< public >*/ /* with LOCK and/or STREAM_LOCK */  /* 所有PAD的集合。  */  /*    * GstCollectData:    * @collect: owner #GstCollectPads    * @pad: #GstPad managed by this data    * @buffer: currently queued buffer.    * @pos: position in the buffer    * @segment: last segment received.    * @dts: the signed version of the DTS converted to running time. To access    *       this memeber, use %GST_COLLECT_PADS_DTS macro. (Since 1.6)    *    * Structure used by the collect_pads.    struct _GstCollectData    {      /* with STREAM_LOCK of @collect */      /* 指向回collectpad。  */      GstCollectPads        *collect;      GstPad                *pad;      GstBuffer             *buffer;      guint                  pos;      GstSegment             segment;          /*< private >*/      /* state: bitfield for easier extension;       * eos, flushing, new_segment, waiting */      GstCollectPadsStateFlags    state;          GstCollectDataPrivate *priv;          union {        struct {          /*< public >*/          gint64 dts;          /*< private >*/        } abi;        gpointer _gst_reserved[GST_PADDING];      } ABI;    };   */  GSList        *data;                  /* list of CollectData items */  /*< private >*/  GRecMutex      stream_lock;          /* used to serialize collection among several streams */  GstCollectPadsPrivate *priv;  gpointer _gst_reserved[GST_PADDING];};

4. 代码分析：

4.1 主入口函数：

        主入口函数gst_collect_pads_chain，不同pad工作于不同线程中。代码分析如下：

/* For each buffer we receive we check if our collected condition is reached * and if so we call the collected function. When this is done we check if * data has been unqueued. If data is still queued we wait holding the stream * lock to make sure no EOS event can happen while we are ready to be * collected  */static GstFlowReturngst_collect_pads_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer){  GstCollectData *data;  GstCollectPads *pads;  GstFlowReturn ret;  GstBuffer **buffer_p;  guint32 cookie;  GST_DEBUG ("Got buffer for pad %s:%s", GST_DEBUG_PAD_NAME (pad));  /* some magic to get the managing collect_pads */  GST_OBJECT_LOCK (pad);  data = (GstCollectData *) gst_pad_get_element_private (pad);  if (G_UNLIKELY (data == NULL))    goto no_data;  ref_data (data);  GST_OBJECT_UNLOCK (pad);  pads = data->collect;  GST_COLLECT_PADS_STREAM_LOCK (pads);  /* 状态判断。  */  /* if not started, bail out */  if (G_UNLIKELY (!pads->priv->started))    goto not_started;  /* check if this pad is flushing */  if (G_UNLIKELY (GST_COLLECT_PADS_STATE_IS_SET (data,              GST_COLLECT_PADS_STATE_FLUSHING)))    goto flushing;  /* pad was EOS, we can refuse this data */  if (G_UNLIKELY (GST_COLLECT_PADS_STATE_IS_SET (data,              GST_COLLECT_PADS_STATE_EOS)))    goto eos;  /* see if we need to clip */  /* 数据前处理。  */  if (pads->priv->clip_func) {    GstBuffer *outbuf = NULL;    ret =        pads->priv->clip_func (pads, data, buffer, &outbuf,        pads->priv->clip_user_data);    buffer = outbuf;    if (G_UNLIKELY (outbuf == NULL))      goto clipped;    if (G_UNLIKELY (ret == GST_FLOW_EOS))      goto eos;    else if (G_UNLIKELY (ret != GST_FLOW_OK))      goto error;  }  GST_DEBUG_OBJECT (pads, "Queuing buffer %p for pad %s:%s", buffer,      GST_DEBUG_PAD_NAME (pad));  /* One more pad has data queued */  // 如果当前collectpad处于WAITING状态会将queuedpads增加  if (GST_COLLECT_PADS_STATE_IS_SET (data, GST_COLLECT_PADS_STATE_WAITING))    pads->priv->queuedpads++;  buffer_p = &data->buffer;  gst_buffer_replace (buffer_p, buffer);  /* update segment last position if in TIME */  /* 更新当前pad上对应的时间信息，后续用于重新计算等待状态需要用到。  */  if (G_LIKELY (data->segment.format == GST_FORMAT_TIME)) {    GstClockTime timestamp;    timestamp = GST_BUFFER_DTS_OR_PTS (buffer);    if (GST_CLOCK_TIME_IS_VALID (timestamp))      data->segment.position = timestamp;  }  /* While we have data queued on this pad try to collect stuff */  do {    /* Check if our collected condition is matched and call the collected     * function if it is */    /* 主要处理函数，判断收集条件是否满足，后续分析。  */    ret = gst_collect_pads_check_collected (pads);    /* when an error occurs, we want to report this back to the caller ASAP     * without having to block if the buffer was not popped */    /* 数据流处理异常，进入异常处理分支。  */    if (G_UNLIKELY (ret != GST_FLOW_OK))      goto error;    /* data was consumed, we can exit and accept new data *//* 当buffer在check_collected函数中被消费，会在其中减少引用次数，释放buffer。 * 数据被处理后退出循环，等待下一次buffer到来调用chain函数。  */    if (data->buffer == NULL)      break;    /* 数据未被处理，未满足数据收集条件，本pad对应线程将进行唤醒等待。  */    /* Having the _INIT here means we don't care about any broadcast up to here     * (most of which occur with STREAM_LOCK held, so could not have happened     * anyway).  We do care about e.g. a remove initiated broadcast as of this     * point.  Putting it here also makes this thread ignores any evt it raised     * itself (as is a usual WAIT semantic).     */    GST_COLLECT_PADS_EVT_INIT (cookie);    /* pad could be removed and re-added */    unref_data (data);    GST_OBJECT_LOCK (pad);    if (G_UNLIKELY ((data = gst_pad_get_element_private (pad)) == NULL))      goto pad_removed;    ref_data (data);    GST_OBJECT_UNLOCK (pad);    GST_DEBUG_OBJECT (pads, "Pad %s:%s has a buffer queued, waiting",        GST_DEBUG_PAD_NAME (pad));    /* wait to be collected, this must happen from another thread triggered     * by the _chain function of another pad. We release the lock so we     * can get stopped or flushed as well. We can however not get EOS     * because we still hold the STREAM_LOCK.     */    /* 等待条件变量被唤醒。  */    GST_COLLECT_PADS_STREAM_UNLOCK (pads);    GST_COLLECT_PADS_EVT_WAIT (pads, cookie);    GST_COLLECT_PADS_STREAM_LOCK (pads);    GST_DEBUG_OBJECT (pads, "Pad %s:%s resuming", GST_DEBUG_PAD_NAME (pad));/* 唤醒后的状态判断。  */    /* after a signal, we could be stopped */    if (G_UNLIKELY (!pads->priv->started))      goto not_started;    /* check if this pad is flushing */    if (G_UNLIKELY (GST_COLLECT_PADS_STATE_IS_SET (data,                GST_COLLECT_PADS_STATE_FLUSHING)))      goto flushing;  }  while (data->buffer != NULL);unlock_done:  GST_COLLECT_PADS_STREAM_UNLOCK (pads);  /* data is definitely NULL if pad_removed goto was run. */  if (data)    unref_data (data);  if (buffer)    gst_buffer_unref (buffer);  return ret;/* 异常状态处理。  */pad_removed:  {    GST_WARNING ("%s got removed from collectpads", GST_OBJECT_NAME (pad));    GST_OBJECT_UNLOCK (pad);    ret = GST_FLOW_NOT_LINKED;    goto unlock_done;  }  /* ERRORS */no_data:  {    GST_DEBUG ("%s got removed from collectpads", GST_OBJECT_NAME (pad));    GST_OBJECT_UNLOCK (pad);    gst_buffer_unref (buffer);    return GST_FLOW_NOT_LINKED;  }not_started:  {    GST_DEBUG ("not started");    gst_collect_pads_clear (pads, data);    ret = GST_FLOW_FLUSHING;    goto unlock_done;  }flushing:  {    GST_DEBUG ("pad %s:%s is flushing", GST_DEBUG_PAD_NAME (pad));    gst_collect_pads_clear (pads, data);    ret = GST_FLOW_FLUSHING;    goto unlock_done;  }eos:  {    /* we should not post an error for this, just inform upstream that     * we don't expect anything anymore */    GST_DEBUG ("pad %s:%s is eos", GST_DEBUG_PAD_NAME (pad));    ret = GST_FLOW_EOS;    goto unlock_done;  }clipped:  {    GST_DEBUG ("clipped buffer on pad %s:%s", GST_DEBUG_PAD_NAME (pad));    ret = GST_FLOW_OK;    goto unlock_done;  }error:  {    /* we print the error, the element should post a reasonable error     * message for fatal errors */    GST_DEBUG ("collect failed, reason %d (%s)", ret, gst_flow_get_name (ret));    gst_collect_pads_clear (pads, data);    goto unlock_done;  }}

4.2 框架上的收集条件判断

        在check函数，首先对collectpads上面的pad状态进行检查，只有当有数据的pads和总的pads数满足一定条件时候，才会执行第二重的收集条件判断。函数为gst_collect_pads_check_collected，代码分析如下：

static GstFlowReturngst_collect_pads_check_collected (GstCollectPads * pads){  GstFlowReturn flow_ret = GST_FLOW_OK;  GstCollectPadsFunction func;  gpointer user_data;  g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), GST_FLOW_ERROR);  /* 获取回调数据。  */  GST_OBJECT_LOCK (pads);  func = pads->priv->func;  user_data = pads->priv->user_data;  GST_OBJECT_UNLOCK (pads);  g_return_val_if_fail (pads->priv->func != NULL, GST_FLOW_NOT_SUPPORTED);  /* check for new pads, update stats etc.. */  /* 主要是对等待唤醒的pad的cookie进行校验。  */  gst_collect_pads_check_pads (pads);  /* 所有pad都是EOS状态。直接处理剩余的所有数据。  */  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->priv->numpads, GST_DEBUG_FUNCPTR_NAME (func));    if (G_UNLIKELY (g_atomic_int_compare_and_exchange (&pads->priv->seeking,                TRUE, FALSE))) {      GST_INFO_OBJECT (pads, "finished seeking");    }    do {      flow_ret = func (pads, user_data);    } while (flow_ret == GST_FLOW_OK);  } else {    /* 有pad处于非EOS状态。  */    gboolean collected = FALSE;    /* We call the collected function as long as our condition matches. */    /* 只有满足(有数据的有效pad数 + 无效pad数 >= 总的pad数)时，才可以进入下一步的     * 条件判断，这个判断是框架级别的判断，总是存在，其余重载的判断函数(func)都在这个循环中处理。     * 如果函数不执行，则buffer一定不会被消费，在外层会走入线程挂起等待唤醒的流程。  */    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));      if (G_UNLIKELY (g_atomic_int_compare_and_exchange (&pads->priv->seeking,                  TRUE, FALSE))) {        GST_INFO_OBJECT (pads, "finished seeking");      }        /* 具体数据的收集条件判断。  */      flow_ret = func (pads, user_data);      collected = TRUE;      /* 数据处理异常或者已经没有有数据的pad了，中断循环。  */      /* break on error */      if (flow_ret != GST_FLOW_OK)        break;      /* Don't keep looping after telling the element EOS or flushing */      if (pads->priv->queuedpads == 0)        break;    }    if (!collected)      GST_DEBUG_OBJECT (pads, "Not all active pads (%d) have data, continuing",          pads->priv->numpads);  }  return flow_ret;}

4.3 默认的第二重收集条件判断

        第二重收集条件的函数是可以进行重载的，可以使用gst_collect_pads_set_function进行设置，这里只分析默认的函数gst_collect_pads_default_collected。

        代码分析如下：

/* * Default collect callback triggered when #GstCollectPads gathered all data. * * Called with STREAM_LOCK. */static GstFlowReturngst_collect_pads_default_collected (GstCollectPads * pads, gpointer user_data){  GstCollectData *best = NULL;  GstBuffer *buffer;  GstFlowReturn ret = GST_FLOW_OK;  GstCollectPadsBufferFunction func;  gpointer buffer_user_data;  g_return_val_if_fail (GST_IS_COLLECT_PADS (pads), GST_FLOW_ERROR);  /* 获取回调数据。  */  GST_OBJECT_LOCK (pads);  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);  /* Find the oldest pad at all cost */  /* 寻找最合适的pad，并计算最早的数据和时间戳。   * 最后返回gst_collect_pads_recalculate_waiting的返回值，   * TRUE表示从非等待状态变为等待状态。   * 在默认场景下，只有使用了set_wait为FALSE时候才会标记为non-waiting状态。   * 因此如果在默认框架下主动设置了non-waiting状态，需要留意时间比较函数。   * 否则这里会进入一个   * FLOW_OK -> 数据没有POP -> pad_num没有变化 -> gst_collect_pads_check_collected主循环中死循环的问题。  */  if (gst_collect_pads_recalculate_full (pads)) {    /* waiting was switched on,     * so give another thread a chance to deliver a possibly     * older buffer; don't charge on yet with the current oldest */    ret = GST_FLOW_OK;    goto done;  }  best = pads->priv->earliest_data;  /* No data collected means EOS. */  /* 在waiting状态下，但是没有最新的数据包，因此认为这个pad已经进入EOS状态了。无法接收数据。   * 注意，这里设置non-waiting以后并修改了时间比较函数后，其他地方调用默认函数，也会导致一个问题：   * 由于non-waiting增加了queuedpad，因此如果总的有两个pad，且两个pad都设置了non-waiting后，在函数   * gst_collect_pads_check_collected中条件判断总是成立，且queuedpad在non-waiting状态下无法自减，   * 第一次进入时候就会把所有的pad的数据直接处理，及时处理完所有数据后，依旧走到这里进行判断，   * 但是这时候buffer已经为空，导致collectpad认为这个pad的数据已经进入EOS状态，处理异常。  */  if (G_UNLIKELY (best == NULL)) {    ret = func (pads, best, NULL, buffer_user_data);    if (ret == GST_FLOW_OK)      ret = GST_FLOW_EOS;    goto done;  }  /* make sure that the pad we take a buffer from is waiting;   * otherwise popping a buffer will seem not to have happened   * and collectpads can get into a busy loop */  gst_collect_pads_set_waiting (pads, best, TRUE);  /* Send buffer */  /* 使用pop弹出buffer，并将buffer发送给buffer_func进行处理。  */  buffer = gst_collect_pads_pop (pads, best);  ret = func (pads, best, buffer, buffer_user_data);  /* maybe non-waiting was forced to waiting above due to   * newsegment events coming too sparsely,   * so re-check to restore state to avoid hanging/waiting */  gst_collect_pads_recalculate_full (pads);done:  return ret;}

        注意，这里如果对某些函数进行重载或者设置了非等待状态，有两个潜在的异常流程。

4.3.1 异常流程1：

        当使用默认的时间比较函数，且设置了非等待状态的pad有数据到来时，在函数gst_collect_pads_recalculate_waiting，当earliest_data检测到本PAD时，这时候时间戳应该是相等的，但是这时候如果处于非等待状态，无论是否加锁最后都会返回TRUE，这时候gst_collect_pads_default_collected函数中的第一个判断总会直接返回GST_FLOW_OK，但是实际并没有弹出任何buffer，但是gst_collect_pads_check_collected的循环条件并没有改变，导致这个线程会一直在这里循环。如果其他pad没有数据进入，则这个pad会进入死循环。

4.3.2 异常流程2：

        当所有的pads都设置了non-waiting状态，则在框架的收集条件判断函数gst_collect_pads_check_collected中的pads数量比较循环总是成立，且所有pads数据弹出时都不会减少当前的queuedpad数，因此当有一个buffer弹出后，会持续弹出所有buffer，当buffer为空时，循环条件依旧成立，在处理空buffer时，认为这个pad已经进入了EOS状态，从而导致异常。异常流程如下图：

4.4 寻找最优的可用buffer和pad

        这个函数流程比较简单，就是遍历collectpads中的所有pad，并和earliest_time进行比较，寻找最早的时间点的buffer。

        这里涉及到时间比较的函数，这里的默认时间比较函数比较简单，就是单纯判断时间点的大小，相等返回0，第一个时间点大于第二个返回1，小于返回-1。

/** * gst_collect_pads_find_best_pad: * @pads: the collectpads to use * @data: returns the collectdata for earliest data * @time: returns the earliest available buffertime * * Find the oldest/best pad, i.e. pad holding the oldest buffer and * and return the corresponding #GstCollectData and buffertime. * * This function should be called with STREAM_LOCK held, * such as in the callback. */static voidgst_collect_pads_find_best_pad (GstCollectPads * pads,    GstCollectData ** data, GstClockTime * time){  GSList *collected;  GstCollectData *best = NULL;  GstClockTime best_time = GST_CLOCK_TIME_NONE;  g_return_if_fail (data != NULL);  g_return_if_fail (time != NULL);  /* 遍历所有pads，对所有pads中的数据与当前的earliest_time进行比较，   * 寻找时间最靠前的buffer及其对应的pad。  */  for (collected = pads->data; collected; collected = g_slist_next (collected)) {    GstBuffer *buffer;    GstCollectData *data = (GstCollectData *) collected->data;    GstClockTime timestamp;    buffer = gst_collect_pads_peek (pads, data);    /* if we have a buffer check if it is better then the current best one */    if (buffer != NULL) {      timestamp = GST_BUFFER_DTS_OR_PTS (buffer);      gst_buffer_unref (buffer);      if (best == NULL || pads->priv->compare_func (pads, data, timestamp,              best, best_time, pads->priv->compare_user_data) < 0) {        best = data;        best_time = timestamp;      }    }  }  /* set earliest time */  *data = best;  *time = best_time;  GST_DEBUG_OBJECT (pads, "best pad %s, best time %" GST_TIME_FORMAT,      best ? GST_PAD_NAME (((GstCollectData *) best)->pad) : "(nil)",      GST_TIME_ARGS (best_time));}

3.5 重新计算等待状态函数

        函数gst_collect_pads_recalculate_waiting会根据earliest_time和所有pad上的数据进行比较，计算collectpad是否需要重新进入等待状态，返回TRUE表示从非等待状态进入等待状态。

        这里如果设置了non-waiting状态，则要小心4.3中出现的异常。

/* General overview: * - only pad with a buffer can determine earliest_data (and earliest_time) * - only segment info determines (non-)waiting state * - ? perhaps use _stream_time for comparison *   (which muxers might have use as well ?) *//* * Function to recalculate the waiting state of all pads. * * Must be called with STREAM_LOCK. * * Returns %TRUE if a pad was set to waiting * (from non-waiting state). */static gbooleangst_collect_pads_recalculate_waiting (GstCollectPads * pads){  GSList *collected;  gboolean result = FALSE;  /* If earliest time is not known, there is nothing to do. */  /* 没有数据可以比较。  */  if (pads->priv->earliest_data == NULL)    return FALSE;  /* 遍历所有pads。  */  for (collected = pads->data; collected; collected = g_slist_next (collected)) {    GstCollectData *data = (GstCollectData *) collected->data;    int cmp_res;    GstClockTime comp_time;    /* check if pad has a segment *//* 检查本pad上对应的时间信息。  */    if (data->segment.format == GST_FORMAT_UNDEFINED) {      GST_WARNING_OBJECT (pads,          "GstCollectPads has no time segment, assuming 0 based.");      gst_segment_init (&data->segment, GST_FORMAT_TIME);      GST_COLLECT_PADS_STATE_SET (data, GST_COLLECT_PADS_STATE_NEW_SEGMENT);    }    /* check segment format */    if (data->segment.format != GST_FORMAT_TIME) {      GST_ERROR_OBJECT (pads, "GstCollectPads can handle only time segments.");      continue;    }    /* check if the waiting state should be changed */    /* 将earliest_time和当前pad上的时间信息进行比较。     * 当cmp_res为1，表示本pad的时间比earliest_time晚，这时候数据可以消费，不需要等待。     * 将返回FALSE，在函数gst_collect_pads_default_collected执行buffer_func消费buffer。     * 否则表示本pad时间比earliest_time早或者相等，如果这时候是在非等待状态，则要设置成等待状态，     * 同时返回TRUE，并在gst_collect_pads_default_collected不处理buffer，返回GST_FLOW_OK，重新计算best。     * 这里要注意设置了non-waiting后的第一个包，第一个包的时间有可能是相同的，即0:00 == 0:00     */    comp_time = data->segment.position;    cmp_res = pads->priv->compare_func (pads, data, comp_time,        pads->priv->earliest_data, pads->priv->earliest_time,        pads->priv->compare_user_data);    if (cmp_res > 0)      /* stop waiting */      gst_collect_pads_set_waiting (pads, data, FALSE);    else {      if (!GST_COLLECT_PADS_STATE_IS_SET (data, GST_COLLECT_PADS_STATE_WAITING)) {        /* start waiting */        gst_collect_pads_set_waiting (pads, data, TRUE);        result = TRUE;      }    }  }  return result;}

4.6 锁和等待状态

        collectpad提供了接口gst_collect_pads_set_waiting可以给其他组件设置某个pad为等待或者非等待状态。其设置与锁GST_COLLECT_PADS_STATE_LOCKED标志位有关系。

        默认情况下的pad（注意，这里的pad为单独的一个pad，并非整个collectpad，这些状态为单个pad私有，并不是collectpad的属性）均为等待状态，而锁的初始化则根据element调用collect添加pad的函数gst_collect_pads_add_pad的最后一个参数决定。

/** * gst_collect_pads_set_waiting: * @pads: the collectpads * @data: the data to use * @waiting: boolean indicating whether this pad should operate *           in waiting or non-waiting mode * * Sets a pad to waiting or non-waiting mode, if at least this pad * has not been created with locked waiting state, * in which case nothing happens. * * This function should be called with @pads STREAM_LOCK held, such as * in the callback. * * MT safe. */voidgst_collect_pads_set_waiting (GstCollectPads * pads, GstCollectData * data,    gboolean waiting){  g_return_if_fail (pads != NULL);  g_return_if_fail (GST_IS_COLLECT_PADS (pads));  g_return_if_fail (data != NULL);  GST_DEBUG_OBJECT (pads, "Setting pad %s to waiting %d, locked %d",      GST_PAD_NAME (data->pad), waiting,      GST_COLLECT_PADS_STATE_IS_SET (data, GST_COLLECT_PADS_STATE_LOCKED));  /* Do something only on a change and if not locked */  /* 修改等待状态标志位需要在没有上锁的情况下处理，   * 可以通过GST_COLLECT_PADS_STATE_SET (data, GST_COLLECT_PADS_STATE_LOCKED);方式加解锁。   * 如果设置为非等待，则会把对应的queuedpad自增，当所有pad都处于非等待状态，则框架收集条件总是满足。   * 可能存在4.3.2的问题。   */  if (!GST_COLLECT_PADS_STATE_IS_SET (data, GST_COLLECT_PADS_STATE_LOCKED) &&      (GST_COLLECT_PADS_STATE_IS_SET (data, GST_COLLECT_PADS_STATE_WAITING) !=          ! !waiting)) {    /* Set waiting state for this pad */    if (waiting)      GST_COLLECT_PADS_STATE_SET (data, GST_COLLECT_PADS_STATE_WAITING);    else      GST_COLLECT_PADS_STATE_UNSET (data, GST_COLLECT_PADS_STATE_WAITING);    /* Update number of queued pads if needed */    if (!data->buffer &&        !GST_COLLECT_PADS_STATE_IS_SET (data, GST_COLLECT_PADS_STATE_EOS)) {      if (waiting)        pads->priv->queuedpads--;      else        pads->priv->queuedpads++;    }    /* signal waiters because something changed */    GST_COLLECT_PADS_EVT_BROADCAST (pads);  }}