/**
* SECTION:gstadapter
+ * @title: GstAdapter
* @short_description: adapts incoming data on a sink pad into chunks of N bytes
*
* This class is for elements that receive buffers in an undesired size.
*
* For example, a sink pad's chain function that needs to pass data to a library
* in 512-byte chunks could be implemented like this:
- * |[
+ * |[<!-- language="C" -->
* static GstFlowReturn
* sink_pad_chain (GstPad *pad, GstObject *parent, GstBuffer *buffer)
* {
* gst_adapter_prev_pts_at_offset() can be used to determine the last
* seen timestamp at a particular offset in the adapter.
*
+ * The adapter will also keep track of the offset of the buffers
+ * (#GST_BUFFER_OFFSET) that were pushed. The last seen offset before the
+ * current position can be queried with gst_adapter_prev_offset(). This function
+ * can optionally return the number of bytes between the start of the buffer
+ * that carried the offset and the current adapter position.
+ *
+ * Additionally the adapter also keeps track of the PTS, DTS and buffer offset
+ * at the last discontinuity, which can be retrieved with
+ * gst_adapter_pts_at_discont(), gst_adapter_dts_at_discont() and
+ * gst_adapter_offset_at_discont(). The number of bytes that were consumed
+ * since then can be queried with gst_adapter_distance_from_discont().
+ *
* A last thing to note is that while #GstAdapter is pretty optimized,
* merging buffers still might be an operation that requires a malloc() and
* memcpy() operation, and these operations are not the fastest. Because of
#include <gst/gst_private.h>
#include "gstadapter.h"
#include <string.h>
+#include <gst/base/gstqueuearray.h>
/* default size for the assembled data buffer */
#define DEFAULT_SIZE 4096
GObject object;
/*< private > */
- GSList *buflist;
- GSList *buflist_end;
+ GstQueueArray *bufqueue;
gsize size;
gsize skip;
+ guint count;
/* we keep state of assembled pieces */
gpointer assembled_data;
guint64 pts_distance;
GstClockTime dts;
guint64 dts_distance;
+ guint64 offset;
+ guint64 offset_distance;
gsize scan_offset;
- GSList *scan_entry;
+ /* G_MAXUINT when unset */
+ guint scan_entry_idx;
+
+ GstClockTime pts_at_discont;
+ GstClockTime dts_at_discont;
+ guint64 offset_at_discont;
+
+ guint64 distance_from_discont;
GstMapInfo info;
};
adapter->pts_distance = 0;
adapter->dts = GST_CLOCK_TIME_NONE;
adapter->dts_distance = 0;
+ adapter->offset = GST_BUFFER_OFFSET_NONE;
+ adapter->offset_distance = 0;
+ adapter->pts_at_discont = GST_CLOCK_TIME_NONE;
+ adapter->dts_at_discont = GST_CLOCK_TIME_NONE;
+ adapter->offset_at_discont = GST_BUFFER_OFFSET_NONE;
+ adapter->distance_from_discont = 0;
+ adapter->bufqueue = gst_queue_array_new (10);
}
static void
g_free (adapter->assembled_data);
+ gst_queue_array_free (adapter->bufqueue);
+
GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
}
GstAdapter *
gst_adapter_new (void)
{
- return g_object_newv (GST_TYPE_ADAPTER, 0, NULL);
+ return g_object_new (GST_TYPE_ADAPTER, NULL);
}
/**
void
gst_adapter_clear (GstAdapter * adapter)
{
+ GstMiniObject *obj;
g_return_if_fail (GST_IS_ADAPTER (adapter));
if (adapter->info.memory)
gst_adapter_unmap (adapter);
- g_slist_foreach (adapter->buflist, (GFunc) gst_mini_object_unref, NULL);
- g_slist_free (adapter->buflist);
- adapter->buflist = NULL;
- adapter->buflist_end = NULL;
+ while ((obj = gst_queue_array_pop_head (adapter->bufqueue)))
+ gst_mini_object_unref (obj);
+
+ adapter->count = 0;
adapter->size = 0;
adapter->skip = 0;
adapter->assembled_len = 0;
adapter->pts_distance = 0;
adapter->dts = GST_CLOCK_TIME_NONE;
adapter->dts_distance = 0;
+ adapter->offset = GST_BUFFER_OFFSET_NONE;
+ adapter->offset_distance = 0;
+ adapter->pts_at_discont = GST_CLOCK_TIME_NONE;
+ adapter->dts_at_discont = GST_CLOCK_TIME_NONE;
+ adapter->offset_at_discont = GST_BUFFER_OFFSET_NONE;
+ adapter->distance_from_discont = 0;
adapter->scan_offset = 0;
- adapter->scan_entry = NULL;
+ adapter->scan_entry_idx = G_MAXUINT;
}
static inline void
-update_timestamps (GstAdapter * adapter, GstBuffer * buf)
+update_timestamps_and_offset (GstAdapter * adapter, GstBuffer * buf)
{
GstClockTime pts, dts;
+ guint64 offset;
pts = GST_BUFFER_PTS (buf);
if (GST_CLOCK_TIME_IS_VALID (pts)) {
adapter->dts = dts;
adapter->dts_distance = 0;
}
+ offset = GST_BUFFER_OFFSET (buf);
+ if (offset != GST_BUFFER_OFFSET_NONE) {
+ GST_LOG_OBJECT (adapter, "new offset %" G_GUINT64_FORMAT, offset);
+ adapter->offset = offset;
+ adapter->offset_distance = 0;
+ }
+
+ if (GST_BUFFER_IS_DISCONT (buf)) {
+ /* Take values as-is (might be NONE) */
+ adapter->pts_at_discont = pts;
+ adapter->dts_at_discont = dts;
+ adapter->offset_at_discont = offset;
+ adapter->distance_from_discont = 0;
+ }
}
/* copy data into @dest, skipping @skip bytes from the head buffers */
copy_into_unchecked (GstAdapter * adapter, guint8 * dest, gsize skip,
gsize size)
{
- GSList *g;
GstBuffer *buf;
gsize bsize, csize;
+ guint idx = 0;
/* first step, do skipping */
/* we might well be copying where we were scanning */
- if (adapter->scan_entry && (adapter->scan_offset <= skip)) {
- g = adapter->scan_entry;
+ if (adapter->scan_entry_idx != G_MAXUINT && (adapter->scan_offset <= skip)) {
+ idx = adapter->scan_entry_idx;
skip -= adapter->scan_offset;
} else {
- g = adapter->buflist;
+ idx = 0;
}
- buf = g->data;
+ buf = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
bsize = gst_buffer_get_size (buf);
while (G_UNLIKELY (skip >= bsize)) {
skip -= bsize;
- g = g_slist_next (g);
- buf = g->data;
+ buf = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
bsize = gst_buffer_get_size (buf);
}
/* copy partial buffer */
/* second step, copy remainder */
while (size > 0) {
- g = g_slist_next (g);
- buf = g->data;
+ buf = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
bsize = gst_buffer_get_size (buf);
if (G_LIKELY (bsize > 0)) {
csize = MIN (bsize, size);
adapter->size += size;
/* Note: merging buffers at this point is premature. */
- if (G_UNLIKELY (adapter->buflist == NULL)) {
+ if (gst_queue_array_is_empty (adapter->bufqueue)) {
GST_LOG_OBJECT (adapter, "pushing %p first %" G_GSIZE_FORMAT " bytes",
buf, size);
- adapter->buflist = adapter->buflist_end = g_slist_append (NULL, buf);
- update_timestamps (adapter, buf);
+ gst_queue_array_push_tail (adapter->bufqueue, buf);
+ update_timestamps_and_offset (adapter, buf);
} else {
/* Otherwise append to the end, and advance our end pointer */
GST_LOG_OBJECT (adapter, "pushing %p %" G_GSIZE_FORMAT " bytes at end, "
"size now %" G_GSIZE_FORMAT, buf, size, adapter->size);
- adapter->buflist_end = g_slist_append (adapter->buflist_end, buf);
- adapter->buflist_end = g_slist_next (adapter->buflist_end);
+ gst_queue_array_push_tail (adapter->bufqueue, buf);
}
+ ++adapter->count;
}
#if 0
#if 0
do {
#endif
- cur = adapter->buflist->data;
+ cur = gst_queue_array_peek_head (adapter->bufqueue);
skip = adapter->skip;
csize = gst_buffer_get_size (cur);
g_return_if_fail (GST_IS_ADAPTER (adapter));
if (adapter->info.memory) {
- GstBuffer *cur = adapter->buflist->data;
+ GstBuffer *cur = gst_queue_array_peek_head (adapter->bufqueue);
GST_LOG_OBJECT (adapter, "unmap memory buffer %p", cur);
gst_buffer_unmap (cur, &adapter->info);
adapter->info.memory = NULL;
{
GstBuffer *cur;
gsize size;
- GSList *g;
GST_LOG_OBJECT (adapter, "flushing %" G_GSIZE_FORMAT " bytes", flush);
/* distance is always at least the amount of skipped bytes */
adapter->pts_distance -= adapter->skip;
adapter->dts_distance -= adapter->skip;
+ adapter->offset_distance -= adapter->skip;
+ adapter->distance_from_discont -= adapter->skip;
- g = adapter->buflist;
- cur = g->data;
+ cur = gst_queue_array_peek_head (adapter->bufqueue);
size = gst_buffer_get_size (cur);
while (flush >= size) {
/* can skip whole buffer */
GST_LOG_OBJECT (adapter, "flushing out head buffer");
adapter->pts_distance += size;
adapter->dts_distance += size;
+ adapter->offset_distance += size;
+ adapter->distance_from_discont += size;
flush -= size;
- gst_buffer_unref (cur);
- g = g_slist_delete_link (g, g);
+ --adapter->count;
+
+ cur = NULL;
+ gst_buffer_unref (gst_queue_array_pop_head (adapter->bufqueue));
- if (G_UNLIKELY (g == NULL)) {
+ if (gst_queue_array_is_empty (adapter->bufqueue)) {
GST_LOG_OBJECT (adapter, "adapter empty now");
- adapter->buflist_end = NULL;
break;
}
/* there is a new head buffer, update the timestamps */
- cur = g->data;
- update_timestamps (adapter, cur);
+ cur = gst_queue_array_peek_head (adapter->bufqueue);
+ update_timestamps_and_offset (adapter, cur);
size = gst_buffer_get_size (cur);
}
- adapter->buflist = g;
/* account for the remaining bytes */
adapter->skip = flush;
adapter->pts_distance += flush;
adapter->dts_distance += flush;
+ adapter->offset_distance += flush;
+ adapter->distance_from_discont += flush;
/* invalidate scan position */
adapter->scan_offset = 0;
- adapter->scan_entry = NULL;
+ adapter->scan_entry_idx = G_MAXUINT;
}
/**
gst_adapter_flush_unchecked (adapter, flush);
}
-/* internal function, nbytes should be flushed after calling this function */
+/* internal function, nbytes should be flushed if needed after calling this function */
static guint8 *
-gst_adapter_take_internal (GstAdapter * adapter, gsize nbytes)
+gst_adapter_get_internal (GstAdapter * adapter, gsize nbytes)
{
guint8 *data;
gsize toreuse, tocopy;
if (G_UNLIKELY (nbytes > adapter->size))
return NULL;
- data = gst_adapter_take_internal (adapter, nbytes);
+ data = gst_adapter_get_internal (adapter, nbytes);
gst_adapter_flush_unchecked (adapter, nbytes);
}
/**
- * gst_adapter_take_buffer_fast:
+ * gst_adapter_get_buffer_fast:
* @adapter: a #GstAdapter
- * @nbytes: the number of bytes to take
+ * @nbytes: the number of bytes to get
*
- * Returns a #GstBuffer containing the first @nbytes of the @adapter.
- * The returned bytes will be flushed from the adapter. This function
- * is potentially more performant than gst_adapter_take_buffer() since
- * it can reuse the memory in pushed buffers by subbuffering or
- * merging. Unlike gst_adapter_take_buffer(), the returned buffer may
- * be composed of multiple non-contiguous #GstMemory objects, no
- * copies are made.
- *
- * Note that no assumptions should be made as to whether certain buffer
- * flags such as the DISCONT flag are set on the returned buffer, or not.
- * The caller needs to explicitly set or unset flags that should be set or
- * unset.
- *
- * This function can return buffer up to the return value of
- * gst_adapter_available() without making copies if possible.
+ * Returns a #GstBuffer containing the first @nbytes of the @adapter, but
+ * does not flush them from the adapter. See gst_adapter_take_buffer_fast()
+ * for details.
*
* Caller owns a reference to the returned buffer. gst_buffer_unref() after
* usage.
* @nbytes of the adapter, or %NULL if @nbytes bytes are not available.
* gst_buffer_unref() when no longer needed.
*
- * Since: 1.2
+ * Since: 1.6
*/
-
GstBuffer *
-gst_adapter_take_buffer_fast (GstAdapter * adapter, gsize nbytes)
+gst_adapter_get_buffer_fast (GstAdapter * adapter, gsize nbytes)
{
GstBuffer *buffer = NULL;
GstBuffer *cur;
- GSList *item;
gsize skip;
gsize left = nbytes;
+ guint idx, len;
g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
g_return_val_if_fail (nbytes > 0, NULL);
- GST_LOG_OBJECT (adapter, "taking buffer of %" G_GSIZE_FORMAT " bytes",
+ GST_LOG_OBJECT (adapter, "getting buffer of %" G_GSIZE_FORMAT " bytes",
nbytes);
/* we don't have enough data, return NULL. This is unlikely
return NULL;
skip = adapter->skip;
- cur = adapter->buflist->data;
+ cur = gst_queue_array_peek_head (adapter->bufqueue);
if (skip == 0 && gst_buffer_get_size (cur) == nbytes) {
GST_LOG_OBJECT (adapter, "providing buffer of %" G_GSIZE_FORMAT " bytes"
goto done;
}
- for (item = adapter->buflist; item && left > 0; item = item->next) {
+ len = gst_queue_array_get_length (adapter->bufqueue);
+
+ for (idx = 0; idx < len && left > 0; idx++) {
gsize size, cur_size;
- cur = item->data;
+ cur = gst_queue_array_peek_nth (adapter->bufqueue, idx);
cur_size = gst_buffer_get_size (cur);
size = MIN (cur_size - skip, left);
GST_LOG_OBJECT (adapter, "appending %" G_GSIZE_FORMAT " bytes"
" via region copy", size);
if (buffer)
- gst_buffer_copy_into (buffer, cur, GST_BUFFER_COPY_MEMORY, skip, size);
+ gst_buffer_copy_into (buffer, cur,
+ GST_BUFFER_COPY_MEMORY | GST_BUFFER_COPY_META, skip, size);
else
buffer = gst_buffer_copy_region (cur, GST_BUFFER_COPY_ALL, skip, size);
skip = 0;
}
done:
- gst_adapter_flush_unchecked (adapter, nbytes);
return buffer;
}
/**
- * gst_adapter_take_buffer:
- * @adapter: a #GstAdapter
+ * gst_adapter_take_buffer_fast:
+ * @adapter: a #GstAdapter
* @nbytes: the number of bytes to take
*
- * Returns a #GstBuffer containing the first @nbytes bytes of the
- * @adapter. The returned bytes will be flushed from the adapter.
- * This function is potentially more performant than
- * gst_adapter_take() since it can reuse the memory in pushed buffers
- * by subbuffering or merging. This function will always return a
- * buffer with a single memory region.
+ * Returns a #GstBuffer containing the first @nbytes of the @adapter.
+ * The returned bytes will be flushed from the adapter. This function
+ * is potentially more performant than gst_adapter_take_buffer() since
+ * it can reuse the memory in pushed buffers by subbuffering or
+ * merging. Unlike gst_adapter_take_buffer(), the returned buffer may
+ * be composed of multiple non-contiguous #GstMemory objects, no
+ * copies are made.
*
* Note that no assumptions should be made as to whether certain buffer
* flags such as the DISCONT flag are set on the returned buffer, or not.
* The caller needs to explicitly set or unset flags that should be set or
* unset.
*
+ * This will also copy over all GstMeta of the input buffers except
+ * for meta with the %GST_META_FLAG_POOLED flag or with the "memory" tag.
+ *
+ * This function can return buffer up to the return value of
+ * gst_adapter_available() without making copies if possible.
+ *
* Caller owns a reference to the returned buffer. gst_buffer_unref() after
* usage.
*
* Returns: (transfer full) (nullable): a #GstBuffer containing the first
* @nbytes of the adapter, or %NULL if @nbytes bytes are not available.
* gst_buffer_unref() when no longer needed.
+ *
+ * Since: 1.2
*/
GstBuffer *
-gst_adapter_take_buffer (GstAdapter * adapter, gsize nbytes)
+gst_adapter_take_buffer_fast (GstAdapter * adapter, gsize nbytes)
+{
+ GstBuffer *buffer;
+
+ g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
+ g_return_val_if_fail (nbytes > 0, NULL);
+
+ buffer = gst_adapter_get_buffer_fast (adapter, nbytes);
+ if (buffer)
+ gst_adapter_flush_unchecked (adapter, nbytes);
+
+ return buffer;
+}
+
+static gboolean
+foreach_metadata (GstBuffer * inbuf, GstMeta ** meta, gpointer user_data)
+{
+ GstBuffer *outbuf = user_data;
+ const GstMetaInfo *info = (*meta)->info;
+ gboolean do_copy = FALSE;
+
+ if (gst_meta_api_type_has_tag (info->api, _gst_meta_tag_memory)) {
+ /* never call the transform_meta with memory specific metadata */
+ GST_DEBUG ("not copying memory specific metadata %s",
+ g_type_name (info->api));
+ do_copy = FALSE;
+ } else {
+ do_copy = TRUE;
+ GST_DEBUG ("copying metadata %s", g_type_name (info->api));
+ }
+
+ if (do_copy && info->transform_func) {
+ GstMetaTransformCopy copy_data = { FALSE, 0, -1 };
+ GST_DEBUG ("copy metadata %s", g_type_name (info->api));
+ /* simply copy then */
+ info->transform_func (outbuf, *meta, inbuf,
+ _gst_meta_transform_copy, ©_data);
+ }
+ return TRUE;
+}
+
+/**
+ * gst_adapter_get_buffer:
+ * @adapter: a #GstAdapter
+ * @nbytes: the number of bytes to get
+ *
+ * Returns a #GstBuffer containing the first @nbytes of the @adapter, but
+ * does not flush them from the adapter. See gst_adapter_take_buffer()
+ * for details.
+ *
+ * Caller owns a reference to the returned buffer. gst_buffer_unref() after
+ * usage.
+ *
+ * Free-function: gst_buffer_unref
+ *
+ * Returns: (transfer full) (nullable): a #GstBuffer containing the first
+ * @nbytes of the adapter, or %NULL if @nbytes bytes are not available.
+ * gst_buffer_unref() when no longer needed.
+ *
+ * Since: 1.6
+ */
+GstBuffer *
+gst_adapter_get_buffer (GstAdapter * adapter, gsize nbytes)
{
GstBuffer *buffer;
GstBuffer *cur;
g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
g_return_val_if_fail (nbytes > 0, NULL);
- GST_LOG_OBJECT (adapter, "taking buffer of %" G_GSIZE_FORMAT " bytes",
+ GST_LOG_OBJECT (adapter, "getting buffer of %" G_GSIZE_FORMAT " bytes",
nbytes);
/* we don't have enough data, return NULL. This is unlikely
if (G_UNLIKELY (nbytes > adapter->size))
return NULL;
- cur = adapter->buflist->data;
+ cur = gst_queue_array_peek_head (adapter->bufqueue);
skip = adapter->skip;
hsize = gst_buffer_get_size (cur);
}
#endif
- data = gst_adapter_take_internal (adapter, nbytes);
+ data = gst_adapter_get_internal (adapter, nbytes);
buffer = gst_buffer_new_wrapped (data, nbytes);
+ {
+ guint idx, len;
+ GstBuffer *cur;
+ gsize read_offset = 0;
+
+ idx = 0;
+ len = gst_queue_array_get_length (adapter->bufqueue);
+
+ while (idx < len && read_offset < nbytes + adapter->skip) {
+ cur = gst_queue_array_peek_nth (adapter->bufqueue, idx);
+
+ gst_buffer_foreach_meta (cur, foreach_metadata, buffer);
+ read_offset += gst_buffer_get_size (cur);
+
+ idx++;
+ }
+ }
+
done:
- gst_adapter_flush_unchecked (adapter, nbytes);
+
+ return buffer;
+}
+
+/**
+ * gst_adapter_take_buffer:
+ * @adapter: a #GstAdapter
+ * @nbytes: the number of bytes to take
+ *
+ * Returns a #GstBuffer containing the first @nbytes bytes of the
+ * @adapter. The returned bytes will be flushed from the adapter.
+ * This function is potentially more performant than
+ * gst_adapter_take() since it can reuse the memory in pushed buffers
+ * by subbuffering or merging. This function will always return a
+ * buffer with a single memory region.
+ *
+ * Note that no assumptions should be made as to whether certain buffer
+ * flags such as the DISCONT flag are set on the returned buffer, or not.
+ * The caller needs to explicitly set or unset flags that should be set or
+ * unset.
+ *
+ * Since 1.6 this will also copy over all GstMeta of the input buffers except
+ * for meta with the %GST_META_FLAG_POOLED flag or with the "memory" tag.
+ *
+ * Caller owns a reference to the returned buffer. gst_buffer_unref() after
+ * usage.
+ *
+ * Free-function: gst_buffer_unref
+ *
+ * Returns: (transfer full) (nullable): a #GstBuffer containing the first
+ * @nbytes of the adapter, or %NULL if @nbytes bytes are not available.
+ * gst_buffer_unref() when no longer needed.
+ */
+GstBuffer *
+gst_adapter_take_buffer (GstAdapter * adapter, gsize nbytes)
+{
+ GstBuffer *buffer;
+
+ g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
+ g_return_val_if_fail (nbytes > 0, NULL);
+
+ buffer = gst_adapter_get_buffer (adapter, nbytes);
+ if (buffer)
+ gst_adapter_flush_unchecked (adapter, nbytes);
return buffer;
}
GST_LOG_OBJECT (adapter, "taking %" G_GSIZE_FORMAT " bytes", nbytes);
while (nbytes > 0) {
- cur = adapter->buflist->data;
+ cur = gst_queue_array_peek_head (adapter->bufqueue);
skip = adapter->skip;
cur_size = gst_buffer_get_size (cur);
hsize = MIN (nbytes, cur_size - skip);
}
/**
+ * gst_adapter_get_list:
+ * @adapter: a #GstAdapter
+ * @nbytes: the number of bytes to get
+ *
+ * Returns a #GList of buffers containing the first @nbytes bytes of the
+ * @adapter, but does not flush them from the adapter. See
+ * gst_adapter_take_list() for details.
+ *
+ * Caller owns returned list and contained buffers. gst_buffer_unref() each
+ * buffer in the list before freeing the list after usage.
+ *
+ * Returns: (element-type Gst.Buffer) (transfer full) (nullable): a #GList of
+ * buffers containing the first @nbytes of the adapter, or %NULL if @nbytes
+ * bytes are not available
+ *
+ * Since: 1.6
+ */
+GList *
+gst_adapter_get_list (GstAdapter * adapter, gsize nbytes)
+{
+ GQueue queue = G_QUEUE_INIT;
+ GstBuffer *cur, *buffer;
+ gsize hsize, skip, cur_size;
+ guint idx;
+
+ g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
+ g_return_val_if_fail (nbytes <= adapter->size, NULL);
+
+ GST_LOG_OBJECT (adapter, "getting %" G_GSIZE_FORMAT " bytes", nbytes);
+
+ idx = 0;
+ skip = adapter->skip;
+
+ while (nbytes > 0) {
+ cur = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
+ cur_size = gst_buffer_get_size (cur);
+ hsize = MIN (nbytes, cur_size - skip);
+
+ if (skip == 0 && cur_size == hsize) {
+ GST_LOG_OBJECT (adapter,
+ "inserting a buffer of %" G_GSIZE_FORMAT " bytes", hsize);
+ buffer = gst_buffer_ref (cur);
+ } else {
+ GST_LOG_OBJECT (adapter, "inserting a buffer of %" G_GSIZE_FORMAT " bytes"
+ " via region copy", hsize);
+ buffer = gst_buffer_copy_region (cur, GST_BUFFER_COPY_ALL, skip, hsize);
+ }
+
+ g_queue_push_tail (&queue, buffer);
+
+ nbytes -= hsize;
+ skip = 0;
+ }
+
+ return queue.head;
+}
+
+/**
* gst_adapter_take_buffer_list:
* @adapter: a #GstAdapter
* @nbytes: the number of bytes to take
GstBufferList *buffer_list;
GstBuffer *cur;
gsize hsize, skip, cur_size;
+ guint n_bufs;
g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
GST_LOG_OBJECT (adapter, "taking %" G_GSIZE_FORMAT " bytes", nbytes);
- buffer_list = gst_buffer_list_new ();
+ /* try to create buffer list with sufficient size, so no resize is done later */
+ if (adapter->count < 64)
+ n_bufs = adapter->count;
+ else
+ n_bufs = (adapter->count * nbytes * 1.2 / adapter->size) + 1;
+
+ buffer_list = gst_buffer_list_new_sized (n_bufs);
+
while (nbytes > 0) {
- cur = adapter->buflist->data;
+ cur = gst_queue_array_peek_head (adapter->bufqueue);
skip = adapter->skip;
cur_size = gst_buffer_get_size (cur);
hsize = MIN (nbytes, cur_size - skip);
}
/**
+ * gst_adapter_get_buffer_list:
+ * @adapter: a #GstAdapter
+ * @nbytes: the number of bytes to get
+ *
+ * Returns a #GstBufferList of buffers containing the first @nbytes bytes of
+ * the @adapter but does not flush them from the adapter. See
+ * gst_adapter_take_buffer_list() for details.
+ *
+ * Caller owns the returned list. Call gst_buffer_list_unref() to free
+ * the list after usage.
+ *
+ * Returns: (transfer full) (nullable): a #GstBufferList of buffers containing
+ * the first @nbytes of the adapter, or %NULL if @nbytes bytes are not
+ * available
+ *
+ * Since: 1.6
+ */
+GstBufferList *
+gst_adapter_get_buffer_list (GstAdapter * adapter, gsize nbytes)
+{
+ GstBufferList *buffer_list;
+ GstBuffer *cur, *buffer;
+ gsize hsize, skip, cur_size;
+ guint n_bufs;
+ guint idx;
+
+ g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
+
+ if (nbytes > adapter->size)
+ return NULL;
+
+ GST_LOG_OBJECT (adapter, "getting %" G_GSIZE_FORMAT " bytes", nbytes);
+
+ /* try to create buffer list with sufficient size, so no resize is done later */
+ if (adapter->count < 64)
+ n_bufs = adapter->count;
+ else
+ n_bufs = (adapter->count * nbytes * 1.2 / adapter->size) + 1;
+
+ buffer_list = gst_buffer_list_new_sized (n_bufs);
+
+ idx = 0;
+ skip = adapter->skip;
+
+ while (nbytes > 0) {
+ cur = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
+ cur_size = gst_buffer_get_size (cur);
+ hsize = MIN (nbytes, cur_size - skip);
+
+ if (skip == 0 && cur_size == hsize) {
+ GST_LOG_OBJECT (adapter,
+ "inserting a buffer of %" G_GSIZE_FORMAT " bytes", hsize);
+ buffer = gst_buffer_ref (cur);
+ } else {
+ GST_LOG_OBJECT (adapter, "inserting a buffer of %" G_GSIZE_FORMAT " bytes"
+ " via region copy", hsize);
+ buffer = gst_buffer_copy_region (cur, GST_BUFFER_COPY_ALL, skip, hsize);
+ }
+
+ gst_buffer_list_add (buffer_list, buffer);
+
+ nbytes -= hsize;
+ skip = 0;
+ }
+
+ return buffer_list;
+}
+
+/**
* gst_adapter_available:
* @adapter: a #GstAdapter
*
{
GstBuffer *cur;
gsize size;
- GSList *g;
+ guint idx;
g_return_val_if_fail (GST_IS_ADAPTER (adapter), 0);
return adapter->assembled_len;
/* take the first non-zero buffer */
- g = adapter->buflist;
+ idx = 0;
while (TRUE) {
- cur = g->data;
+ cur = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
size = gst_buffer_get_size (cur);
if (size != 0)
break;
- g = g_slist_next (g);
}
/* we can quickly get the (remaining) data of the first buffer */
}
/**
+ * gst_adapter_get_distance_from_discont:
+ * @adapter: a #GstAdapter
+ *
+ * Get the distance in bytes since the last buffer with the
+ * %GST_BUFFER_FLAG_DISCONT flag.
+ *
+ * The distance will be reset to 0 for all buffers with
+ * %GST_BUFFER_FLAG_DISCONT on them, and then calculated for all other
+ * following buffers based on their size.
+ *
+ * Since: 1.10
+ *
+ * Returns: The offset. Can be %GST_BUFFER_OFFSET_NONE.
+ */
+guint64
+gst_adapter_distance_from_discont (GstAdapter * adapter)
+{
+ return adapter->distance_from_discont;
+}
+
+/**
+ * gst_adapter_offset_at_discont:
+ * @adapter: a #GstAdapter
+ *
+ * Get the offset that was on the last buffer with the GST_BUFFER_FLAG_DISCONT
+ * flag, or GST_BUFFER_OFFSET_NONE.
+ *
+ * Since: 1.10
+ *
+ * Returns: The offset at the last discont or GST_BUFFER_OFFSET_NONE.
+ */
+guint64
+gst_adapter_offset_at_discont (GstAdapter * adapter)
+{
+ g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_BUFFER_OFFSET_NONE);
+
+ return adapter->offset_at_discont;
+}
+
+/**
+ * gst_adapter_pts_at_discont:
+ * @adapter: a #GstAdapter
+ *
+ * Get the PTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT
+ * flag, or GST_CLOCK_TIME_NONE.
+ *
+ * Since: 1.10
+ *
+ * Returns: The PTS at the last discont or GST_CLOCK_TIME_NONE.
+ */
+GstClockTime
+gst_adapter_pts_at_discont (GstAdapter * adapter)
+{
+ g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_CLOCK_TIME_NONE);
+
+ return adapter->pts_at_discont;
+}
+
+/**
+ * gst_adapter_dts_at_discont:
+ * @adapter: a #GstAdapter
+ *
+ * Get the DTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT
+ * flag, or GST_CLOCK_TIME_NONE.
+ *
+ * Since: 1.10
+ *
+ * Returns: The DTS at the last discont or GST_CLOCK_TIME_NONE.
+ */
+GstClockTime
+gst_adapter_dts_at_discont (GstAdapter * adapter)
+{
+ g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_CLOCK_TIME_NONE);
+
+ return adapter->dts_at_discont;
+}
+
+/**
+ * gst_adapter_prev_offset:
+ * @adapter: a #GstAdapter
+ * @distance: (out) (allow-none): pointer to a location for distance, or %NULL
+ *
+ * Get the offset that was before the current byte in the adapter. When
+ * @distance is given, the amount of bytes between the offset and the current
+ * position is returned.
+ *
+ * The offset is reset to GST_BUFFER_OFFSET_NONE and the distance is set to 0
+ * when the adapter is first created or when it is cleared. This also means that
+ * before the first byte with an offset is removed from the adapter, the offset
+ * and distance returned are GST_BUFFER_OFFSET_NONE and 0 respectively.
+ *
+ * Since: 1.10
+ *
+ * Returns: The previous seen offset.
+ */
+guint64
+gst_adapter_prev_offset (GstAdapter * adapter, guint64 * distance)
+{
+ g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_BUFFER_OFFSET_NONE);
+
+ if (distance)
+ *distance = adapter->offset_distance;
+
+ return adapter->offset;
+}
+
+/**
* gst_adapter_prev_pts:
* @adapter: a #GstAdapter
* @distance: (out) (allow-none): pointer to location for distance, or %NULL
guint64 * distance)
{
GstBuffer *cur;
- GSList *g;
gsize read_offset = 0;
+ gsize pts_offset = 0;
GstClockTime pts = adapter->pts;
+ guint idx, len;
g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_CLOCK_TIME_NONE);
- g = adapter->buflist;
+ idx = 0;
+ len = gst_queue_array_get_length (adapter->bufqueue);
- while (g && read_offset < offset + adapter->skip) {
- cur = g->data;
+ while (idx < len && read_offset < offset + adapter->skip) {
+ cur = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
- read_offset += gst_buffer_get_size (cur);
if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_PTS (cur))) {
pts = GST_BUFFER_PTS (cur);
+ pts_offset = read_offset;
}
- g = g_slist_next (g);
+ read_offset += gst_buffer_get_size (cur);
}
if (distance)
- *distance = adapter->dts_distance + offset;
+ *distance = adapter->pts_distance + offset - pts_offset;
return pts;
}
guint64 * distance)
{
GstBuffer *cur;
- GSList *g;
gsize read_offset = 0;
+ gsize dts_offset = 0;
GstClockTime dts = adapter->dts;
+ guint idx, len;
g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_CLOCK_TIME_NONE);
- g = adapter->buflist;
+ idx = 0;
+ len = gst_queue_array_get_length (adapter->bufqueue);
- while (g && read_offset < offset + adapter->skip) {
- cur = g->data;
+ while (idx < len && read_offset < offset + adapter->skip) {
+ cur = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
- read_offset += gst_buffer_get_size (cur);
if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DTS (cur))) {
dts = GST_BUFFER_DTS (cur);
+ dts_offset = read_offset;
}
- g = g_slist_next (g);
+ read_offset += gst_buffer_get_size (cur);
}
if (distance)
- *distance = adapter->dts_distance + offset;
+ *distance = adapter->dts_distance + offset - dts_offset;
return dts;
}
gst_adapter_masked_scan_uint32_peek (GstAdapter * adapter, guint32 mask,
guint32 pattern, gsize offset, gsize size, guint32 * value)
{
- GSList *g;
gsize skip, bsize, i;
guint32 state;
GstMapInfo info;
guint8 *bdata;
GstBuffer *buf;
+ guint idx;
g_return_val_if_fail (size > 0, -1);
g_return_val_if_fail (offset + size <= adapter->size, -1);
/* first step, do skipping and position on the first buffer */
/* optimistically assume scanning continues sequentially */
- if (adapter->scan_entry && (adapter->scan_offset <= skip)) {
- g = adapter->scan_entry;
+ if (adapter->scan_entry_idx != G_MAXUINT && (adapter->scan_offset <= skip)) {
+ idx = adapter->scan_entry_idx;
skip -= adapter->scan_offset;
} else {
- g = adapter->buflist;
+ idx = 0;
adapter->scan_offset = 0;
- adapter->scan_entry = NULL;
+ adapter->scan_entry_idx = G_MAXUINT;
}
- buf = g->data;
+ buf = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
bsize = gst_buffer_get_size (buf);
while (G_UNLIKELY (skip >= bsize)) {
skip -= bsize;
- g = g_slist_next (g);
adapter->scan_offset += bsize;
- adapter->scan_entry = g;
- buf = g->data;
+ adapter->scan_entry_idx = idx;
+ buf = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
bsize = gst_buffer_get_size (buf);
}
/* get the data now */
/* nothing found yet, go to next buffer */
skip += bsize;
- g = g_slist_next (g);
adapter->scan_offset += info.size;
- adapter->scan_entry = g;
+ adapter->scan_entry_idx = idx;
gst_buffer_unmap (buf, &info);
- buf = g->data;
+ buf = gst_queue_array_peek_nth (adapter->bufqueue, idx++);
if (!gst_buffer_map (buf, &info, GST_MAP_READ))
return -1;
* Returns: offset of the first match, or -1 if no match was found.
*
* Example:
- * <programlisting>
+ * |[
* // Assume the adapter contains 0x00 0x01 0x02 ... 0xfe 0xff
*
* gst_adapter_masked_scan_uint32 (adapter, 0xffffffff, 0x00010203, 0, 256);
* // -> returns 2
* gst_adapter_masked_scan_uint32 (adapter, 0xffff0000, 0x02030000, 0, 4);
* // -> returns -1
- * </programlisting>
+ * ]|
*/
gssize
gst_adapter_masked_scan_uint32 (GstAdapter * adapter, guint32 mask,