GstCollectData

typedef struct {
  /* with LOCK of @collect */
  GstCollectPads 	*collect;
  GstPad		*pad;
  GstBuffer		*buffer;
  guint			 pos;
  GstSegment             segment;
} GstCollectData;

Structure used by the collect_pads.

GstCollectPads

typedef struct {
  GSList	*data;                  /* list of CollectData items */
} GstCollectPads;

Collectpads object.

GstCollectPadsFunction ()

GstFlowReturn       (*GstCollectPadsFunction)           (GstCollectPads *pads,
                                                         gpointer user_data);

A function that will be called when all pads have received data.

GstCollectDataDestroyNotify ()

void                (*GstCollectDataDestroyNotify)      (GstCollectData *data);

A function that will be called when the GstCollectData will be freed. It is passed the pointer to the structure and should free any custom memory and resources allocated for it.

Since 0.10.12

gst_collect_pads_new ()

GstCollectPads*     gst_collect_pads_new                (void);

Create a new instance of GstCollectsPads.

gst_collect_pads_set_function ()

void                gst_collect_pads_set_function       (GstCollectPads *pads,
                                                         GstCollectPadsFunction func,
                                                         gpointer user_data);

Set the callback function and user data that will be called when all the pads added to the collection have buffers queued.

MT safe.

gst_collect_pads_add_pad ()

GstCollectData*     gst_collect_pads_add_pad            (GstCollectPads *pads,
                                                         GstPad *pad,
                                                         guint size);

Add a pad to the collection of collect pads. The pad has to be a sinkpad. The refcount of the pad is incremented. Use gst_collect_pads_remove_pad() to remove the pad from the collection again.

You specify a size for the returned GstCollectData structure so that you can use it to store additional information.

The pad will be automatically activated in push mode when pads is started.

This function calls gst_collect_pads_add_pad() passing a value of NULL for destroy_notify.

gst_collect_pads_add_pad_full ()

GstCollectData*     gst_collect_pads_add_pad_full       (GstCollectPads *pads,
                                                         GstPad *pad,
                                                         guint size,
                                                         GstCollectDataDestroyNotify destroy_notify);

Add a pad to the collection of collect pads. The pad has to be a sinkpad. The refcount of the pad is incremented. Use gst_collect_pads_remove_pad() to remove the pad from the collection again.

You specify a size for the returned GstCollectData structure so that you can use it to store additional information.

You can also specify a GstCollectDataDestroyNotify that will be called just before the GstCollectData structure is freed. It is passed the pointer to the structure and should free any custom memory and resources allocated for it.

The pad will be automatically activated in push mode when pads is started.

Since 0.10.12

gst_collect_pads_remove_pad ()

gboolean            gst_collect_pads_remove_pad         (GstCollectPads *pads,
                                                         GstPad *pad);

Remove a pad from the collection of collect pads. This function will also free the GstCollectData and all the resources that were allocated with gst_collect_pads_add_pad().

The pad will be deactivated automatically when pads is stopped.

gst_collect_pads_is_active ()

gboolean            gst_collect_pads_is_active          (GstCollectPads *pads,
                                                         GstPad *pad);

Check if a pad is active.

This function is currently not implemented.

gst_collect_pads_collect ()

GstFlowReturn       gst_collect_pads_collect            (GstCollectPads *pads);

Collect data on all pads. This function is usually called from a GstTask function in an element.

This function is currently not implemented.

gst_collect_pads_collect_range ()

GstFlowReturn       gst_collect_pads_collect_range      (GstCollectPads *pads,
                                                         guint64 offset,
                                                         guint length);

Collect data with offset and length on all pads. This function is typically called in the getrange function of an element.

This function is currently not implemented.

gst_collect_pads_start ()

void                gst_collect_pads_start              (GstCollectPads *pads);

Starts the processing of data in the collect_pads.

MT safe.

gst_collect_pads_stop ()

void                gst_collect_pads_stop               (GstCollectPads *pads);

Stops the processing of data in the collect_pads. this function will also unblock any blocking operations.

MT safe.

gst_collect_pads_set_flushing ()

void                gst_collect_pads_set_flushing       (GstCollectPads *pads,
                                                         gboolean flushing);

Change the flushing state of all the pads in the collection. No pad is able to accept anymore data when flushing is TRUE. Calling this function with flushing FALSE makes pads accept data again.

MT safe.

Since 0.10.7.

gst_collect_pads_peek ()

GstBuffer*          gst_collect_pads_peek               (GstCollectPads *pads,
                                                         GstCollectData *data);

Peek at the buffer currently queued in data. This function should be called with the pads LOCK held, such as in the callback handler.

gst_collect_pads_pop ()

GstBuffer*          gst_collect_pads_pop                (GstCollectPads *pads,
                                                         GstCollectData *data);

Pop the buffer currently queued in data. This function should be called with the pads LOCK held, such as in the callback handler.

gst_collect_pads_available ()

guint               gst_collect_pads_available          (GstCollectPads *pads);

Query how much bytes can be read from each queued buffer. This means that the result of this call is the maximum number of bytes that can be read from each of the pads.

This function should be called with pads LOCK held, such as in the callback.

gst_collect_pads_read ()

guint               gst_collect_pads_read               (GstCollectPads *pads,
                                                         GstCollectData *data,
                                                         guint8 **bytes,
                                                         guint size);

Get a pointer in bytes where size bytes can be read from the given pad data.

This function should be called with pads LOCK held, such as in the callback.

gst_collect_pads_read_buffer ()

GstBuffer*          gst_collect_pads_read_buffer        (GstCollectPads *pads,
                                                         GstCollectData *data,
                                                         guint size);

Get a subbuffer of size bytes from the given pad data.

This function should be called with pads LOCK held, such as in the callback.

Since 0.10.18

gst_collect_pads_take_buffer ()

GstBuffer*          gst_collect_pads_take_buffer        (GstCollectPads *pads,
                                                         GstCollectData *data,
                                                         guint size);

Get a subbuffer of size bytes from the given pad data. Flushes the amount of read bytes.

This function should be called with pads LOCK held, such as in the callback.

Since 0.10.18

gst_collect_pads_flush ()

guint               gst_collect_pads_flush              (GstCollectPads *pads,
                                                         GstCollectData *data,
                                                         guint size);

Flush size bytes from the pad data.

This function should be called with pads LOCK held, such as in the callback.