libs/gst/base/gstadapter.c

   1 /* GStreamer
   2  * Copyright (C) 2004 Benjamin Otte <otte@gnome.org>
   3  *               2005 Wim Taymans <wim@fluendo.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:gstadapter
  23  * @short_description: adapts incoming data on a sink pad into chunks of N bytes
  24  *
  25  * This class is for elements that receive buffers in an undesired size.
  26  * While for example raw video contains one image per buffer, the same is not
  27  * true for a lot of other formats, especially those that come directly from
  28  * a file. So if you have undefined buffer sizes and require a specific size,
  29  * this object is for you.
  30  *
  31  * An adapter is created with gst_adapter_new(). It can be freed again with
  32  * g_object_unref().
  33  *
  34  * The theory of operation is like this: All buffers received are put
  35  * into the adapter using gst_adapter_push() and the data is then read back
  36  * in chunks of the desired size using gst_adapter_map()/gst_adapter_unmap()
  37  * and/or gst_adapter_copy(). After the data has been processed, it is freed
  38  * using gst_adapter_unmap().
  39  *
  40  * Other methods such as gst_adapter_take() and gst_adapter_take_buffer()
  41  * combine gst_adapter_map() and gst_adapter_unmap() in one method and are
  42  * potentially more convenient for some use cases.
  43  *
  44  * For example, a sink pad's chain function that needs to pass data to a library
  45  * in 512-byte chunks could be implemented like this:
  46  * |[
  47  * static GstFlowReturn
  48  * sink_pad_chain (GstPad *pad, GstObject *parent, GstBuffer *buffer)
  49  * {
  50  *   MyElement *this;
  51  *   GstAdapter *adapter;
  52  *   GstFlowReturn ret = GST_FLOW_OK;
  53  *
  54  *   this = MY_ELEMENT (parent);
  55  *
  56  *   adapter = this->adapter;
  57  *
  58  *   // put buffer into adapter
  59  *   gst_adapter_push (adapter, buffer);
  60  *
  61  *   // while we can read out 512 bytes, process them
  62  *   while (gst_adapter_available (adapter) >= 512 && ret == GST_FLOW_OK) {
  63  *     const guint8 *data = gst_adapter_map (adapter, 512);
  64  *     // use flowreturn as an error value
  65  *     ret = my_library_foo (data);
  66  *     gst_adapter_unmap (adapter);
  67  *     gst_adapter_flush (adapter, 512);
  68  *   }
  69  *   return ret;
  70  * }
  71  * ]|
  72  *
  73  * For another example, a simple element inside GStreamer that uses #GstAdapter
  74  * is the libvisual element.
  75  *
  76  * An element using #GstAdapter in its sink pad chain function should ensure that
  77  * when the FLUSH_STOP event is received, that any queued data is cleared using
  78  * gst_adapter_clear(). Data should also be cleared or processed on EOS and
  79  * when changing state from %GST_STATE_PAUSED to %GST_STATE_READY.
  80  *
  81  * Also check the GST_BUFFER_FLAG_DISCONT flag on the buffer. Some elements might
  82  * need to clear the adapter after a discontinuity.
  83  *
  84  * The adapter will keep track of the timestamps of the buffers
  85  * that were pushed. The last seen timestamp before the current position
  86  * can be queried with gst_adapter_prev_pts(). This function can
  87  * optionally return the number of bytes between the start of the buffer that
  88  * carried the timestamp and the current adapter position. The distance is
  89  * useful when dealing with, for example, raw audio samples because it allows
  90  * you to calculate the timestamp of the current adapter position by using the
  91  * last seen timestamp and the amount of bytes since.  Additionally, the
  92  * gst_adapter_prev_pts_at_offset() can be used to determine the last
  93  * seen timestamp at a particular offset in the adapter.
  94  *
  95  * A last thing to note is that while #GstAdapter is pretty optimized,
  96  * merging buffers still might be an operation that requires a malloc() and
  97  * memcpy() operation, and these operations are not the fastest. Because of
  98  * this, some functions like gst_adapter_available_fast() are provided to help
  99  * speed up such cases should you want to. To avoid repeated memory allocations,
 100  * gst_adapter_copy() can be used to copy data into a (statically allocated)
 101  * user provided buffer.
 102  *
 103  * #GstAdapter is not MT safe. All operations on an adapter must be serialized by
 104  * the caller. This is not normally a problem, however, as the normal use case
 105  * of #GstAdapter is inside one pad's chain function, in which case access is
 106  * serialized via the pad's STREAM_LOCK.
 107  *
 108  * Note that gst_adapter_push() takes ownership of the buffer passed. Use
 109  * gst_buffer_ref() before pushing it into the adapter if you still want to
 110  * access the buffer later. The adapter will never modify the data in the
 111  * buffer pushed in it.
 112  */
 113
 114 #include <gst/gst_private.h>
 115 #include "gstadapter.h"
 116 #include <string.h>
 117
 118 /* default size for the assembled data buffer */
 119 #define DEFAULT_SIZE 4096
 120
 121 static void gst_adapter_flush_unchecked (GstAdapter * adapter, gsize flush);
 122
 123 GST_DEBUG_CATEGORY_STATIC (gst_adapter_debug);
 124 #define GST_CAT_DEFAULT gst_adapter_debug
 125
 126 struct _GstAdapter
 127 {
 128   GObject object;
 129
 130   /*< private > */
 131   GSList *buflist;
 132   GSList *buflist_end;
 133   gsize size;
 134   gsize skip;
 135   guint count;
 136
 137   /* we keep state of assembled pieces */
 138   gpointer assembled_data;
 139   gsize assembled_size;
 140   gsize assembled_len;
 141
 142   GstClockTime pts;
 143   guint64 pts_distance;
 144   GstClockTime dts;
 145   guint64 dts_distance;
 146
 147   gsize scan_offset;
 148   GSList *scan_entry;
 149
 150   GstMapInfo info;
 151 };
 152
 153 struct _GstAdapterClass
 154 {
 155   GObjectClass parent_class;
 156 };
 157
 158 #define _do_init \
 159   GST_DEBUG_CATEGORY_INIT (gst_adapter_debug, "adapter", 0, "object to splice and merge buffers to desired size")
 160 #define gst_adapter_parent_class parent_class
 161 G_DEFINE_TYPE_WITH_CODE (GstAdapter, gst_adapter, G_TYPE_OBJECT, _do_init);
 162
 163 static void gst_adapter_dispose (GObject * object);
 164 static void gst_adapter_finalize (GObject * object);
 165
 166 static void
 167 gst_adapter_class_init (GstAdapterClass * klass)
 168 {
 169   GObjectClass *object = G_OBJECT_CLASS (klass);
 170
 171   object->dispose = gst_adapter_dispose;
 172   object->finalize = gst_adapter_finalize;
 173 }
 174
 175 static void
 176 gst_adapter_init (GstAdapter * adapter)
 177 {
 178   adapter->assembled_data = g_malloc (DEFAULT_SIZE);
 179   adapter->assembled_size = DEFAULT_SIZE;
 180   adapter->pts = GST_CLOCK_TIME_NONE;
 181   adapter->pts_distance = 0;
 182   adapter->dts = GST_CLOCK_TIME_NONE;
 183   adapter->dts_distance = 0;
 184 }
 185
 186 static void
 187 gst_adapter_dispose (GObject * object)
 188 {
 189   GstAdapter *adapter = GST_ADAPTER (object);
 190
 191   gst_adapter_clear (adapter);
 192
 193   GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
 194 }
 195
 196 static void
 197 gst_adapter_finalize (GObject * object)
 198 {
 199   GstAdapter *adapter = GST_ADAPTER (object);
 200
 201   g_free (adapter->assembled_data);
 202
 203   GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
 204 }
 205
 206 /**
 207  * gst_adapter_new:
 208  *
 209  * Creates a new #GstAdapter. Free with g_object_unref().
 210  *
 211  * Returns: (transfer full): a new #GstAdapter
 212  */
 213 GstAdapter *
 214 gst_adapter_new (void)
 215 {
 216   return g_object_newv (GST_TYPE_ADAPTER, 0, NULL);
 217 }
 218
 219 /**
 220  * gst_adapter_clear:
 221  * @adapter: a #GstAdapter
 222  *
 223  * Removes all buffers from @adapter.
 224  */
 225 void
 226 gst_adapter_clear (GstAdapter * adapter)
 227 {
 228   g_return_if_fail (GST_IS_ADAPTER (adapter));
 229
 230   if (adapter->info.memory)
 231     gst_adapter_unmap (adapter);
 232
 233   g_slist_foreach (adapter->buflist, (GFunc) gst_mini_object_unref, NULL);
 234   g_slist_free (adapter->buflist);
 235   adapter->buflist = NULL;
 236   adapter->buflist_end = NULL;
 237   adapter->count = 0;
 238   adapter->size = 0;
 239   adapter->skip = 0;
 240   adapter->assembled_len = 0;
 241   adapter->pts = GST_CLOCK_TIME_NONE;
 242   adapter->pts_distance = 0;
 243   adapter->dts = GST_CLOCK_TIME_NONE;
 244   adapter->dts_distance = 0;
 245   adapter->scan_offset = 0;
 246   adapter->scan_entry = NULL;
 247 }
 248
 249 static inline void
 250 update_timestamps (GstAdapter * adapter, GstBuffer * buf)
 251 {
 252   GstClockTime pts, dts;
 253
 254   pts = GST_BUFFER_PTS (buf);
 255   if (GST_CLOCK_TIME_IS_VALID (pts)) {
 256     GST_LOG_OBJECT (adapter, "new pts %" GST_TIME_FORMAT, GST_TIME_ARGS (pts));
 257     adapter->pts = pts;
 258     adapter->pts_distance = 0;
 259   }
 260   dts = GST_BUFFER_DTS (buf);
 261   if (GST_CLOCK_TIME_IS_VALID (dts)) {
 262     GST_LOG_OBJECT (adapter, "new dts %" GST_TIME_FORMAT, GST_TIME_ARGS (dts));
 263     adapter->dts = dts;
 264     adapter->dts_distance = 0;
 265   }
 266 }
 267
 268 /* copy data into @dest, skipping @skip bytes from the head buffers */
 269 static void
 270 copy_into_unchecked (GstAdapter * adapter, guint8 * dest, gsize skip,
 271     gsize size)
 272 {
 273   GSList *g;
 274   GstBuffer *buf;
 275   gsize bsize, csize;
 276
 277   /* first step, do skipping */
 278   /* we might well be copying where we were scanning */
 279   if (adapter->scan_entry && (adapter->scan_offset <= skip)) {
 280     g = adapter->scan_entry;
 281     skip -= adapter->scan_offset;
 282   } else {
 283     g = adapter->buflist;
 284   }
 285   buf = g->data;
 286   bsize = gst_buffer_get_size (buf);
 287   while (G_UNLIKELY (skip >= bsize)) {
 288     skip -= bsize;
 289     g = g_slist_next (g);
 290     buf = g->data;
 291     bsize = gst_buffer_get_size (buf);
 292   }
 293   /* copy partial buffer */
 294   csize = MIN (bsize - skip, size);
 295   GST_DEBUG ("bsize %" G_GSIZE_FORMAT ", skip %" G_GSIZE_FORMAT ", csize %"
 296       G_GSIZE_FORMAT, bsize, skip, csize);
 297   GST_CAT_LOG_OBJECT (GST_CAT_PERFORMANCE, adapter, "extract %" G_GSIZE_FORMAT
 298       " bytes", csize);
 299   gst_buffer_extract (buf, skip, dest, csize);
 300   size -= csize;
 301   dest += csize;
 302
 303   /* second step, copy remainder */
 304   while (size > 0) {
 305     g = g_slist_next (g);
 306     buf = g->data;
 307     bsize = gst_buffer_get_size (buf);
 308     if (G_LIKELY (bsize > 0)) {
 309       csize = MIN (bsize, size);
 310       GST_CAT_LOG_OBJECT (GST_CAT_PERFORMANCE, adapter,
 311           "extract %" G_GSIZE_FORMAT " bytes", csize);
 312       gst_buffer_extract (buf, 0, dest, csize);
 313       size -= csize;
 314       dest += csize;
 315     }
 316   }
 317 }
 318
 319 /**
 320  * gst_adapter_push:
 321  * @adapter: a #GstAdapter
 322  * @buf: (transfer full): a #GstBuffer to add to queue in the adapter
 323  *
 324  * Adds the data from @buf to the data stored inside @adapter and takes
 325  * ownership of the buffer.
 326  */
 327 void
 328 gst_adapter_push (GstAdapter * adapter, GstBuffer * buf)
 329 {
 330   gsize size;
 331
 332   g_return_if_fail (GST_IS_ADAPTER (adapter));
 333   g_return_if_fail (GST_IS_BUFFER (buf));
 334
 335   size = gst_buffer_get_size (buf);
 336   adapter->size += size;
 337
 338   /* Note: merging buffers at this point is premature. */
 339   if (G_UNLIKELY (adapter->buflist == NULL)) {
 340     GST_LOG_OBJECT (adapter, "pushing %p first %" G_GSIZE_FORMAT " bytes",
 341         buf, size);
 342     adapter->buflist = adapter->buflist_end = g_slist_append (NULL, buf);
 343     update_timestamps (adapter, buf);
 344   } else {
 345     /* Otherwise append to the end, and advance our end pointer */
 346     GST_LOG_OBJECT (adapter, "pushing %p %" G_GSIZE_FORMAT " bytes at end, "
 347         "size now %" G_GSIZE_FORMAT, buf, size, adapter->size);
 348     adapter->buflist_end = g_slist_append (adapter->buflist_end, buf);
 349     adapter->buflist_end = g_slist_next (adapter->buflist_end);
 350   }
 351   ++adapter->count;
 352 }
 353
 354 #if 0
 355 /* Internal method only. Tries to merge buffers at the head of the queue
 356  * to form a single larger buffer of size 'size'.
 357  *
 358  * Returns %TRUE if it managed to merge anything.
 359  */
 360 static gboolean
 361 gst_adapter_try_to_merge_up (GstAdapter * adapter, gsize size)
 362 {
 363   GstBuffer *cur, *head;
 364   GSList *g;
 365   gboolean ret = FALSE;
 366   gsize hsize;
 367
 368   g = adapter->buflist;
 369   if (g == NULL)
 370     return FALSE;
 371
 372   head = g->data;
 373
 374   hsize = gst_buffer_get_size (head);
 375
 376   /* Remove skipped part from the buffer (otherwise the buffer might grow indefinitely) */
 377   head = gst_buffer_make_writable (head);
 378   gst_buffer_resize (head, adapter->skip, hsize - adapter->skip);
 379   hsize -= adapter->skip;
 380   adapter->skip = 0;
 381   g->data = head;
 382
 383   g = g_slist_next (g);
 384
 385   while (g != NULL && hsize < size) {
 386     cur = g->data;
 387     /* Merge the head buffer and the next in line */
 388     GST_LOG_OBJECT (adapter, "Merging buffers of size %" G_GSIZE_FORMAT " & %"
 389         G_GSIZE_FORMAT " in search of target %" G_GSIZE_FORMAT,
 390         hsize, gst_buffer_get_size (cur), size);
 391
 392     head = gst_buffer_append (head, cur);
 393     hsize = gst_buffer_get_size (head);
 394     ret = TRUE;
 395
 396     /* Delete the front list item, and store our new buffer in the 2nd list
 397      * item */
 398     adapter->buflist = g_slist_delete_link (adapter->buflist, adapter->buflist);
 399     g->data = head;
 400
 401     /* invalidate scan position */
 402     adapter->scan_offset = 0;
 403     adapter->scan_entry = NULL;
 404
 405     g = g_slist_next (g);
 406   }
 407
 408   return ret;
 409 }
 410 #endif
 411
 412 /**
 413  * gst_adapter_map:
 414  * @adapter: a #GstAdapter
 415  * @size: the number of bytes to map/peek
 416  *
 417  * Gets the first @size bytes stored in the @adapter. The returned pointer is
 418  * valid until the next function is called on the adapter.
 419  *
 420  * Note that setting the returned pointer as the data of a #GstBuffer is
 421  * incorrect for general-purpose plugins. The reason is that if a downstream
 422  * element stores the buffer so that it has access to it outside of the bounds
 423  * of its chain function, the buffer will have an invalid data pointer after
 424  * your element flushes the bytes. In that case you should use
 425  * gst_adapter_take(), which returns a freshly-allocated buffer that you can set
 426  * as #GstBuffer memory or the potentially more performant
 427  * gst_adapter_take_buffer().
 428  *
 429  * Returns %NULL if @size bytes are not available.
 430  *
 431  * Returns: (transfer none) (array length=size) (element-type guint8) (nullable):
 432  *     a pointer to the first @size bytes of data, or %NULL
 433  */
 434 gconstpointer
 435 gst_adapter_map (GstAdapter * adapter, gsize size)
 436 {
 437   GstBuffer *cur;
 438   gsize skip, csize;
 439   gsize toreuse, tocopy;
 440   guint8 *data;
 441
 442   g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
 443   g_return_val_if_fail (size > 0, NULL);
 444
 445   if (adapter->info.memory)
 446     gst_adapter_unmap (adapter);
 447
 448   /* we don't have enough data, return NULL. This is unlikely
 449    * as one usually does an _available() first instead of peeking a
 450    * random size. */
 451   if (G_UNLIKELY (size > adapter->size))
 452     return NULL;
 453
 454   /* we have enough assembled data, return it */
 455   if (adapter->assembled_len >= size)
 456     return adapter->assembled_data;
 457
 458 #if 0
 459   do {
 460 #endif
 461     cur = adapter->buflist->data;
 462     skip = adapter->skip;
 463
 464     csize = gst_buffer_get_size (cur);
 465     if (csize >= size + skip) {
 466       if (!gst_buffer_map (cur, &adapter->info, GST_MAP_READ))
 467         return FALSE;
 468
 469       return (guint8 *) adapter->info.data + skip;
 470     }
 471     /* We may be able to efficiently merge buffers in our pool to
 472      * gather a big enough chunk to return it from the head buffer directly */
 473 #if 0
 474   } while (gst_adapter_try_to_merge_up (adapter, size));
 475 #endif
 476
 477   /* see how much data we can reuse from the assembled memory and how much
 478    * we need to copy */
 479   toreuse = adapter->assembled_len;
 480   tocopy = size - toreuse;
 481
 482   /* Gonna need to copy stuff out */
 483   if (G_UNLIKELY (adapter->assembled_size < size)) {
 484     adapter->assembled_size = (size / DEFAULT_SIZE + 1) * DEFAULT_SIZE;
 485     GST_DEBUG_OBJECT (adapter, "resizing internal buffer to %" G_GSIZE_FORMAT,
 486         adapter->assembled_size);
 487     if (toreuse == 0) {
 488       GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "alloc new buffer");
 489       /* no g_realloc to avoid a memcpy that is not desired here since we are
 490        * not going to reuse any data here */
 491       g_free (adapter->assembled_data);
 492       adapter->assembled_data = g_malloc (adapter->assembled_size);
 493     } else {
 494       /* we are going to reuse all data, realloc then */
 495       GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "reusing %" G_GSIZE_FORMAT " bytes",
 496           toreuse);
 497       adapter->assembled_data =
 498           g_realloc (adapter->assembled_data, adapter->assembled_size);
 499     }
 500   }
 501   GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy remaining %" G_GSIZE_FORMAT
 502       " bytes from adapter", tocopy);
 503   data = adapter->assembled_data;
 504   copy_into_unchecked (adapter, data + toreuse, skip + toreuse, tocopy);
 505   adapter->assembled_len = size;
 506
 507   return adapter->assembled_data;
 508 }
 509
 510 /**
 511  * gst_adapter_unmap:
 512  * @adapter: a #GstAdapter
 513  *
 514  * Releases the memory obtained with the last gst_adapter_map().
 515  */
 516 void
 517 gst_adapter_unmap (GstAdapter * adapter)
 518 {
 519   g_return_if_fail (GST_IS_ADAPTER (adapter));
 520
 521   if (adapter->info.memory) {
 522     GstBuffer *cur = adapter->buflist->data;
 523     GST_LOG_OBJECT (adapter, "unmap memory buffer %p", cur);
 524     gst_buffer_unmap (cur, &adapter->info);
 525     adapter->info.memory = NULL;
 526   }
 527 }
 528
 529 /**
 530  * gst_adapter_copy: (skip)
 531  * @adapter: a #GstAdapter
 532  * @dest: (out caller-allocates) (array length=size) (element-type guint8):
 533  *     the memory to copy into
 534  * @offset: the bytes offset in the adapter to start from
 535  * @size: the number of bytes to copy
 536  *
 537  * Copies @size bytes of data starting at @offset out of the buffers
 538  * contained in #GstAdapter into an array @dest provided by the caller.
 539  *
 540  * The array @dest should be large enough to contain @size bytes.
 541  * The user should check that the adapter has (@offset + @size) bytes
 542  * available before calling this function.
 543  */
 544 void
 545 gst_adapter_copy (GstAdapter * adapter, gpointer dest, gsize offset, gsize size)
 546 {
 547   g_return_if_fail (GST_IS_ADAPTER (adapter));
 548   g_return_if_fail (size > 0);
 549   g_return_if_fail (offset + size <= adapter->size);
 550
 551   copy_into_unchecked (adapter, dest, offset + adapter->skip, size);
 552 }
 553
 554 /**
 555  * gst_adapter_copy_bytes: (rename-to gst_adapter_copy)
 556  * @adapter: a #GstAdapter
 557  * @offset: the bytes offset in the adapter to start from
 558  * @size: the number of bytes to copy
 559  *
 560  * Similar to gst_adapter_copy, but more suitable for language bindings. @size
 561  * bytes of data starting at @offset will be copied out of the buffers contained
 562  * in @adapter and into a new #GBytes structure which is returned. Depending on
 563  * the value of the @size argument an empty #GBytes structure may be returned.
 564  *
 565  * Returns: (transfer full): A new #GBytes structure containing the copied data.
 566  *
 567  * Since: 1.4
 568  */
 569 GBytes *
 570 gst_adapter_copy_bytes (GstAdapter * adapter, gsize offset, gsize size)
 571 {
 572   gpointer data;
 573   data = g_malloc (size);
 574   gst_adapter_copy (adapter, data, offset, size);
 575   return g_bytes_new_take (data, size);
 576 }
 577
 578 /*Flushes the first @flush bytes in the @adapter*/
 579 static void
 580 gst_adapter_flush_unchecked (GstAdapter * adapter, gsize flush)
 581 {
 582   GstBuffer *cur;
 583   gsize size;
 584   GSList *g;
 585
 586   GST_LOG_OBJECT (adapter, "flushing %" G_GSIZE_FORMAT " bytes", flush);
 587
 588   if (adapter->info.memory)
 589     gst_adapter_unmap (adapter);
 590
 591   /* clear state */
 592   adapter->size -= flush;
 593   adapter->assembled_len = 0;
 594
 595   /* take skip into account */
 596   flush += adapter->skip;
 597   /* distance is always at least the amount of skipped bytes */
 598   adapter->pts_distance -= adapter->skip;
 599   adapter->dts_distance -= adapter->skip;
 600
 601   g = adapter->buflist;
 602   cur = g->data;
 603   size = gst_buffer_get_size (cur);
 604   while (flush >= size) {
 605     /* can skip whole buffer */
 606     GST_LOG_OBJECT (adapter, "flushing out head buffer");
 607     adapter->pts_distance += size;
 608     adapter->dts_distance += size;
 609     flush -= size;
 610
 611     gst_buffer_unref (cur);
 612     g = g_slist_delete_link (g, g);
 613     --adapter->count;
 614
 615     if (G_UNLIKELY (g == NULL)) {
 616       GST_LOG_OBJECT (adapter, "adapter empty now");
 617       adapter->buflist_end = NULL;
 618       break;
 619     }
 620     /* there is a new head buffer, update the timestamps */
 621     cur = g->data;
 622     update_timestamps (adapter, cur);
 623     size = gst_buffer_get_size (cur);
 624   }
 625   adapter->buflist = g;
 626   /* account for the remaining bytes */
 627   adapter->skip = flush;
 628   adapter->pts_distance += flush;
 629   adapter->dts_distance += flush;
 630   /* invalidate scan position */
 631   adapter->scan_offset = 0;
 632   adapter->scan_entry = NULL;
 633 }
 634
 635 /**
 636  * gst_adapter_flush:
 637  * @adapter: a #GstAdapter
 638  * @flush: the number of bytes to flush
 639  *
 640  * Flushes the first @flush bytes in the @adapter. The caller must ensure that
 641  * at least this many bytes are available.
 642  *
 643  * See also: gst_adapter_map(), gst_adapter_unmap()
 644  */
 645 void
 646 gst_adapter_flush (GstAdapter * adapter, gsize flush)
 647 {
 648   g_return_if_fail (GST_IS_ADAPTER (adapter));
 649   g_return_if_fail (flush <= adapter->size);
 650
 651   /* flushing out 0 bytes will do nothing */
 652   if (G_UNLIKELY (flush == 0))
 653     return;
 654
 655   gst_adapter_flush_unchecked (adapter, flush);
 656 }
 657
 658 /* internal function, nbytes should be flushed after calling this function */
 659 static guint8 *
 660 gst_adapter_take_internal (GstAdapter * adapter, gsize nbytes)
 661 {
 662   guint8 *data;
 663   gsize toreuse, tocopy;
 664
 665   /* see how much data we can reuse from the assembled memory and how much
 666    * we need to copy */
 667   toreuse = MIN (nbytes, adapter->assembled_len);
 668   tocopy = nbytes - toreuse;
 669
 670   /* find memory to return */
 671   if (adapter->assembled_size >= nbytes && toreuse > 0) {
 672     /* we reuse already allocated memory but only when we're going to reuse
 673      * something from it because else we are worse than the malloc and copy
 674      * case below */
 675     GST_LOG_OBJECT (adapter, "reusing %" G_GSIZE_FORMAT " bytes of assembled"
 676         " data", toreuse);
 677     /* we have enough free space in the assembled array */
 678     data = adapter->assembled_data;
 679     /* flush after this function should set the assembled_size to 0 */
 680     adapter->assembled_data = g_malloc (adapter->assembled_size);
 681   } else {
 682     GST_LOG_OBJECT (adapter, "allocating %" G_GSIZE_FORMAT " bytes", nbytes);
 683     /* not enough bytes in the assembled array, just allocate new space */
 684     data = g_malloc (nbytes);
 685     /* reuse what we can from the already assembled data */
 686     if (toreuse) {
 687       GST_LOG_OBJECT (adapter, "reusing %" G_GSIZE_FORMAT " bytes", toreuse);
 688       GST_CAT_LOG_OBJECT (GST_CAT_PERFORMANCE, adapter,
 689           "memcpy %" G_GSIZE_FORMAT " bytes", toreuse);
 690       memcpy (data, adapter->assembled_data, toreuse);
 691     }
 692   }
 693   if (tocopy) {
 694     /* copy the remaining data */
 695     copy_into_unchecked (adapter, toreuse + data, toreuse + adapter->skip,
 696         tocopy);
 697   }
 698   return data;
 699 }
 700
 701 /**
 702  * gst_adapter_take:
 703  * @adapter: a #GstAdapter
 704  * @nbytes: the number of bytes to take
 705  *
 706  * Returns a freshly allocated buffer containing the first @nbytes bytes of the
 707  * @adapter. The returned bytes will be flushed from the adapter.
 708  *
 709  * Caller owns returned value. g_free after usage.
 710  *
 711  * Free-function: g_free
 712  *
 713  * Returns: (transfer full) (array length=nbytes) (element-type guint8) (nullable):
 714  *     oven-fresh hot data, or %NULL if @nbytes bytes are not available
 715  */
 716 gpointer
 717 gst_adapter_take (GstAdapter * adapter, gsize nbytes)
 718 {
 719   gpointer data;
 720
 721   g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
 722   g_return_val_if_fail (nbytes > 0, NULL);
 723
 724   /* we don't have enough data, return NULL. This is unlikely
 725    * as one usually does an _available() first instead of peeking a
 726    * random size. */
 727   if (G_UNLIKELY (nbytes > adapter->size))
 728     return NULL;
 729
 730   data = gst_adapter_take_internal (adapter, nbytes);
 731
 732   gst_adapter_flush_unchecked (adapter, nbytes);
 733
 734   return data;
 735 }
 736
 737 /**
 738  * gst_adapter_take_buffer_fast:
 739  * @adapter:  a #GstAdapter
 740  * @nbytes: the number of bytes to take
 741  *
 742  * Returns a #GstBuffer containing the first @nbytes of the @adapter.
 743  * The returned bytes will be flushed from the adapter.  This function
 744  * is potentially more performant than gst_adapter_take_buffer() since
 745  * it can reuse the memory in pushed buffers by subbuffering or
 746  * merging. Unlike gst_adapter_take_buffer(), the returned buffer may
 747  * be composed of multiple non-contiguous #GstMemory objects, no
 748  * copies are made.
 749  *
 750  * Note that no assumptions should be made as to whether certain buffer
 751  * flags such as the DISCONT flag are set on the returned buffer, or not.
 752  * The caller needs to explicitly set or unset flags that should be set or
 753  * unset.
 754  *
 755  * This will also copy over all GstMeta of the input buffers except
 756  * for meta with the %GST_META_FLAG_POOLED flag or with the "memory" tag.
 757  *
 758  * This function can return buffer up to the return value of
 759  * gst_adapter_available() without making copies if possible.
 760  *
 761  * Caller owns a reference to the returned buffer. gst_buffer_unref() after
 762  * usage.
 763  *
 764  * Free-function: gst_buffer_unref
 765  *
 766  * Returns: (transfer full) (nullable): a #GstBuffer containing the first
 767  *     @nbytes of the adapter, or %NULL if @nbytes bytes are not available.
 768  *     gst_buffer_unref() when no longer needed.
 769  *
 770  * Since: 1.2
 771  */
 772
 773 GstBuffer *
 774 gst_adapter_take_buffer_fast (GstAdapter * adapter, gsize nbytes)
 775 {
 776   GstBuffer *buffer = NULL;
 777   GstBuffer *cur;
 778   GSList *item;
 779   gsize skip;
 780   gsize left = nbytes;
 781
 782   g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
 783   g_return_val_if_fail (nbytes > 0, NULL);
 784
 785   GST_LOG_OBJECT (adapter, "taking buffer of %" G_GSIZE_FORMAT " bytes",
 786       nbytes);
 787
 788   /* we don't have enough data, return NULL. This is unlikely
 789    * as one usually does an _available() first instead of grabbing a
 790    * random size. */
 791   if (G_UNLIKELY (nbytes > adapter->size))
 792     return NULL;
 793
 794   skip = adapter->skip;
 795   cur = adapter->buflist->data;
 796
 797   if (skip == 0 && gst_buffer_get_size (cur) == nbytes) {
 798     GST_LOG_OBJECT (adapter, "providing buffer of %" G_GSIZE_FORMAT " bytes"
 799         " as head buffer", nbytes);
 800     buffer = gst_buffer_ref (cur);
 801     goto done;
 802   }
 803
 804   for (item = adapter->buflist; item && left > 0; item = item->next) {
 805     gsize size, cur_size;
 806
 807     cur = item->data;
 808     cur_size = gst_buffer_get_size (cur);
 809     size = MIN (cur_size - skip, left);
 810
 811     GST_LOG_OBJECT (adapter, "appending %" G_GSIZE_FORMAT " bytes"
 812         " via region copy", size);
 813     if (buffer)
 814       gst_buffer_copy_into (buffer, cur, GST_BUFFER_COPY_MEMORY, skip, size);
 815     else
 816       buffer = gst_buffer_copy_region (cur, GST_BUFFER_COPY_ALL, skip, size);
 817     skip = 0;
 818     left -= size;
 819   }
 820
 821 done:
 822   gst_adapter_flush_unchecked (adapter, nbytes);
 823
 824   return buffer;
 825 }
 826
 827 static gboolean
 828 foreach_metadata (GstBuffer * inbuf, GstMeta ** meta, gpointer user_data)
 829 {
 830   GstBuffer *outbuf = user_data;
 831   const GstMetaInfo *info = (*meta)->info;
 832   gboolean do_copy = FALSE;
 833
 834   if (GST_META_FLAG_IS_SET (*meta, GST_META_FLAG_POOLED)) {
 835     /* never call the transform_meta with pool private metadata */
 836     GST_DEBUG ("not copying pooled metadata %s", g_type_name (info->api));
 837     do_copy = FALSE;
 838   } else if (gst_meta_api_type_has_tag (info->api, _gst_meta_tag_memory)) {
 839     /* never call the transform_meta with memory specific metadata */
 840     GST_DEBUG ("not copying memory specific metadata %s",
 841         g_type_name (info->api));
 842     do_copy = FALSE;
 843   } else {
 844     do_copy = TRUE;
 845     GST_DEBUG ("copying metadata %s", g_type_name (info->api));
 846   }
 847
 848   if (do_copy) {
 849     GstMetaTransformCopy copy_data = { FALSE, 0, -1 };
 850     GST_DEBUG ("copy metadata %s", g_type_name (info->api));
 851     /* simply copy then */
 852     info->transform_func (outbuf, *meta, inbuf,
 853         _gst_meta_transform_copy, &copy_data);
 854   }
 855   return TRUE;
 856 }
 857
 858 /**
 859  * gst_adapter_take_buffer:
 860  * @adapter: a #GstAdapter
 861  * @nbytes: the number of bytes to take
 862  *
 863  * Returns a #GstBuffer containing the first @nbytes bytes of the
 864  * @adapter. The returned bytes will be flushed from the adapter.
 865  * This function is potentially more performant than
 866  * gst_adapter_take() since it can reuse the memory in pushed buffers
 867  * by subbuffering or merging. This function will always return a
 868  * buffer with a single memory region.
 869  *
 870  * Note that no assumptions should be made as to whether certain buffer
 871  * flags such as the DISCONT flag are set on the returned buffer, or not.
 872  * The caller needs to explicitly set or unset flags that should be set or
 873  * unset.
 874  *
 875  * Since 1.6 this will also copy over all GstMeta of the input buffers except
 876  * for meta with the %GST_META_FLAG_POOLED flag or with the "memory" tag.
 877  *
 878  * Caller owns a reference to the returned buffer. gst_buffer_unref() after
 879  * usage.
 880  *
 881  * Free-function: gst_buffer_unref
 882  *
 883  * Returns: (transfer full) (nullable): a #GstBuffer containing the first
 884  *     @nbytes of the adapter, or %NULL if @nbytes bytes are not available.
 885  *     gst_buffer_unref() when no longer needed.
 886  */
 887 GstBuffer *
 888 gst_adapter_take_buffer (GstAdapter * adapter, gsize nbytes)
 889 {
 890   GstBuffer *buffer;
 891   GstBuffer *cur;
 892   gsize hsize, skip;
 893   guint8 *data;
 894
 895   g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
 896   g_return_val_if_fail (nbytes > 0, NULL);
 897
 898   GST_LOG_OBJECT (adapter, "taking buffer of %" G_GSIZE_FORMAT " bytes",
 899       nbytes);
 900
 901   /* we don't have enough data, return NULL. This is unlikely
 902    * as one usually does an _available() first instead of grabbing a
 903    * random size. */
 904   if (G_UNLIKELY (nbytes > adapter->size))
 905     return NULL;
 906
 907   cur = adapter->buflist->data;
 908   skip = adapter->skip;
 909   hsize = gst_buffer_get_size (cur);
 910
 911   /* our head buffer has enough data left, return it */
 912   if (skip == 0 && hsize == nbytes) {
 913     GST_LOG_OBJECT (adapter, "providing buffer of %" G_GSIZE_FORMAT " bytes"
 914         " as head buffer", nbytes);
 915     buffer = gst_buffer_ref (cur);
 916     goto done;
 917   } else if (hsize >= nbytes + skip) {
 918     GST_LOG_OBJECT (adapter, "providing buffer of %" G_GSIZE_FORMAT " bytes"
 919         " via region copy", nbytes);
 920     buffer = gst_buffer_copy_region (cur, GST_BUFFER_COPY_ALL, skip, nbytes);
 921     goto done;
 922   }
 923 #if 0
 924   if (gst_adapter_try_to_merge_up (adapter, nbytes)) {
 925     /* Merged something, let's try again for sub-buffering */
 926     cur = adapter->buflist->data;
 927     skip = adapter->skip;
 928     if (gst_buffer_get_size (cur) >= nbytes + skip) {
 929       GST_LOG_OBJECT (adapter, "providing buffer of %" G_GSIZE_FORMAT " bytes"
 930           " via sub-buffer", nbytes);
 931       buffer = gst_buffer_copy_region (cur, GST_BUFFER_COPY_ALL, skip, nbytes);
 932       goto done;
 933     }
 934   }
 935 #endif
 936
 937   data = gst_adapter_take_internal (adapter, nbytes);
 938
 939   buffer = gst_buffer_new_wrapped (data, nbytes);
 940
 941   {
 942     GSList *g;
 943     GstBuffer *cur;
 944     gsize read_offset = 0;
 945
 946     g = adapter->buflist;
 947     while (g && read_offset < nbytes + adapter->skip) {
 948       cur = g->data;
 949
 950       gst_buffer_foreach_meta (cur, foreach_metadata, buffer);
 951       read_offset += gst_buffer_get_size (cur);
 952
 953       g = g_slist_next (g);
 954     }
 955   }
 956
 957 done:
 958   gst_adapter_flush_unchecked (adapter, nbytes);
 959
 960   return buffer;
 961 }
 962
 963 /**
 964  * gst_adapter_take_list:
 965  * @adapter: a #GstAdapter
 966  * @nbytes: the number of bytes to take
 967  *
 968  * Returns a #GList of buffers containing the first @nbytes bytes of the
 969  * @adapter. The returned bytes will be flushed from the adapter.
 970  * When the caller can deal with individual buffers, this function is more
 971  * performant because no memory should be copied.
 972  *
 973  * Caller owns returned list and contained buffers. gst_buffer_unref() each
 974  * buffer in the list before freeing the list after usage.
 975  *
 976  * Returns: (element-type Gst.Buffer) (transfer full) (nullable): a #GList of
 977  *     buffers containing the first @nbytes of the adapter, or %NULL if @nbytes
 978  *     bytes are not available
 979  */
 980 GList *
 981 gst_adapter_take_list (GstAdapter * adapter, gsize nbytes)
 982 {
 983   GQueue queue = G_QUEUE_INIT;
 984   GstBuffer *cur;
 985   gsize hsize, skip, cur_size;
 986
 987   g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
 988   g_return_val_if_fail (nbytes <= adapter->size, NULL);
 989
 990   GST_LOG_OBJECT (adapter, "taking %" G_GSIZE_FORMAT " bytes", nbytes);
 991
 992   while (nbytes > 0) {
 993     cur = adapter->buflist->data;
 994     skip = adapter->skip;
 995     cur_size = gst_buffer_get_size (cur);
 996     hsize = MIN (nbytes, cur_size - skip);
 997
 998     cur = gst_adapter_take_buffer (adapter, hsize);
 999
1000     g_queue_push_tail (&queue, cur);
1001
1002     nbytes -= hsize;
1003   }
1004   return queue.head;
1005 }
1006
1007 /**
1008  * gst_adapter_take_buffer_list:
1009  * @adapter: a #GstAdapter
1010  * @nbytes: the number of bytes to take
1011  *
1012  * Returns a #GstBufferList of buffers containing the first @nbytes bytes of
1013  * the @adapter. The returned bytes will be flushed from the adapter.
1014  * When the caller can deal with individual buffers, this function is more
1015  * performant because no memory should be copied.
1016  *
1017  * Caller owns the returned list. Call gst_buffer_list_unref() to free
1018  * the list after usage.
1019  *
1020  * Returns: (transfer full) (nullable): a #GstBufferList of buffers containing
1021  *     the first @nbytes of the adapter, or %NULL if @nbytes bytes are not
1022  *     available
1023  *
1024  * Since: 1.6
1025  */
1026 GstBufferList *
1027 gst_adapter_take_buffer_list (GstAdapter * adapter, gsize nbytes)
1028 {
1029   GstBufferList *buffer_list;
1030   GstBuffer *cur;
1031   gsize hsize, skip, cur_size;
1032   guint n_bufs;
1033
1034   g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
1035
1036   if (nbytes > adapter->size)
1037     return NULL;
1038
1039   GST_LOG_OBJECT (adapter, "taking %" G_GSIZE_FORMAT " bytes", nbytes);
1040
1041   /* try to create buffer list with sufficient size, so no resize is done later */
1042   if (adapter->count < 64)
1043     n_bufs = adapter->count;
1044   else
1045     n_bufs = (adapter->count * nbytes * 1.2 / adapter->size) + 1;
1046
1047   buffer_list = gst_buffer_list_new_sized (n_bufs);
1048
1049   while (nbytes > 0) {
1050     cur = adapter->buflist->data;
1051     skip = adapter->skip;
1052     cur_size = gst_buffer_get_size (cur);
1053     hsize = MIN (nbytes, cur_size - skip);
1054
1055     gst_buffer_list_add (buffer_list, gst_adapter_take_buffer (adapter, hsize));
1056     nbytes -= hsize;
1057   }
1058   return buffer_list;
1059 }
1060
1061 /**
1062  * gst_adapter_available:
1063  * @adapter: a #GstAdapter
1064  *
1065  * Gets the maximum amount of bytes available, that is it returns the maximum
1066  * value that can be supplied to gst_adapter_map() without that function
1067  * returning %NULL.
1068  *
1069  * Returns: number of bytes available in @adapter
1070  */
1071 gsize
1072 gst_adapter_available (GstAdapter * adapter)
1073 {
1074   g_return_val_if_fail (GST_IS_ADAPTER (adapter), 0);
1075
1076   return adapter->size;
1077 }
1078
1079 /**
1080  * gst_adapter_available_fast:
1081  * @adapter: a #GstAdapter
1082  *
1083  * Gets the maximum number of bytes that are immediately available without
1084  * requiring any expensive operations (like copying the data into a
1085  * temporary buffer).
1086  *
1087  * Returns: number of bytes that are available in @adapter without expensive
1088  * operations
1089  */
1090 gsize
1091 gst_adapter_available_fast (GstAdapter * adapter)
1092 {
1093   GstBuffer *cur;
1094   gsize size;
1095   GSList *g;
1096
1097   g_return_val_if_fail (GST_IS_ADAPTER (adapter), 0);
1098
1099   /* no data */
1100   if (adapter->size == 0)
1101     return 0;
1102
1103   /* some stuff we already assembled */
1104   if (adapter->assembled_len)
1105     return adapter->assembled_len;
1106
1107   /* take the first non-zero buffer */
1108   g = adapter->buflist;
1109   while (TRUE) {
1110     cur = g->data;
1111     size = gst_buffer_get_size (cur);
1112     if (size != 0)
1113       break;
1114     g = g_slist_next (g);
1115   }
1116
1117   /* we can quickly get the (remaining) data of the first buffer */
1118   return size - adapter->skip;
1119 }
1120
1121 /**
1122  * gst_adapter_prev_pts:
1123  * @adapter: a #GstAdapter
1124  * @distance: (out) (allow-none): pointer to location for distance, or %NULL
1125  *
1126  * Get the pts that was before the current byte in the adapter. When
1127  * @distance is given, the amount of bytes between the pts and the current
1128  * position is returned.
1129  *
1130  * The pts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when
1131  * the adapter is first created or when it is cleared. This also means that before
1132  * the first byte with a pts is removed from the adapter, the pts
1133  * and distance returned are GST_CLOCK_TIME_NONE and 0 respectively.
1134  *
1135  * Returns: The previously seen pts.
1136  */
1137 GstClockTime
1138 gst_adapter_prev_pts (GstAdapter * adapter, guint64 * distance)
1139 {
1140   g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_CLOCK_TIME_NONE);
1141
1142   if (distance)
1143     *distance = adapter->pts_distance;
1144
1145   return adapter->pts;
1146 }
1147
1148 /**
1149  * gst_adapter_prev_dts:
1150  * @adapter: a #GstAdapter
1151  * @distance: (out) (allow-none): pointer to location for distance, or %NULL
1152  *
1153  * Get the dts that was before the current byte in the adapter. When
1154  * @distance is given, the amount of bytes between the dts and the current
1155  * position is returned.
1156  *
1157  * The dts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when
1158  * the adapter is first created or when it is cleared. This also means that before
1159  * the first byte with a dts is removed from the adapter, the dts
1160  * and distance returned are GST_CLOCK_TIME_NONE and 0 respectively.
1161  *
1162  * Returns: The previously seen dts.
1163  */
1164 GstClockTime
1165 gst_adapter_prev_dts (GstAdapter * adapter, guint64 * distance)
1166 {
1167   g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_CLOCK_TIME_NONE);
1168
1169   if (distance)
1170     *distance = adapter->dts_distance;
1171
1172   return adapter->dts;
1173 }
1174
1175 /**
1176  * gst_adapter_prev_pts_at_offset:
1177  * @adapter: a #GstAdapter
1178  * @offset: the offset in the adapter at which to get timestamp
1179  * @distance: (out) (allow-none): pointer to location for distance, or %NULL
1180  *
1181  * Get the pts that was before the byte at offset @offset in the adapter. When
1182  * @distance is given, the amount of bytes between the pts and the current
1183  * position is returned.
1184  *
1185  * The pts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when
1186  * the adapter is first created or when it is cleared. This also means that before
1187  * the first byte with a pts is removed from the adapter, the pts
1188  * and distance returned are GST_CLOCK_TIME_NONE and 0 respectively.
1189  *
1190  * Since: 1.2
1191  * Returns: The previously seen pts at given offset.
1192  */
1193 GstClockTime
1194 gst_adapter_prev_pts_at_offset (GstAdapter * adapter, gsize offset,
1195     guint64 * distance)
1196 {
1197   GstBuffer *cur;
1198   GSList *g;
1199   gsize read_offset = 0;
1200   GstClockTime pts = adapter->pts;
1201
1202   g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_CLOCK_TIME_NONE);
1203
1204   g = adapter->buflist;
1205
1206   while (g && read_offset < offset + adapter->skip) {
1207     cur = g->data;
1208
1209     read_offset += gst_buffer_get_size (cur);
1210     if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_PTS (cur))) {
1211       pts = GST_BUFFER_PTS (cur);
1212     }
1213
1214     g = g_slist_next (g);
1215   }
1216
1217   if (distance)
1218     *distance = adapter->dts_distance + offset;
1219
1220   return pts;
1221 }
1222
1223 /**
1224  * gst_adapter_prev_dts_at_offset:
1225  * @adapter: a #GstAdapter
1226  * @offset: the offset in the adapter at which to get timestamp
1227  * @distance: (out) (allow-none): pointer to location for distance, or %NULL
1228  *
1229  * Get the dts that was before the byte at offset @offset in the adapter. When
1230  * @distance is given, the amount of bytes between the dts and the current
1231  * position is returned.
1232  *
1233  * The dts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when
1234  * the adapter is first created or when it is cleared. This also means that before
1235  * the first byte with a dts is removed from the adapter, the dts
1236  * and distance returned are GST_CLOCK_TIME_NONE and 0 respectively.
1237  *
1238  * Since: 1.2
1239  * Returns: The previously seen dts at given offset.
1240  */
1241 GstClockTime
1242 gst_adapter_prev_dts_at_offset (GstAdapter * adapter, gsize offset,
1243     guint64 * distance)
1244 {
1245   GstBuffer *cur;
1246   GSList *g;
1247   gsize read_offset = 0;
1248   GstClockTime dts = adapter->dts;
1249
1250   g_return_val_if_fail (GST_IS_ADAPTER (adapter), GST_CLOCK_TIME_NONE);
1251
1252   g = adapter->buflist;
1253
1254   while (g && read_offset < offset + adapter->skip) {
1255     cur = g->data;
1256
1257     read_offset += gst_buffer_get_size (cur);
1258     if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DTS (cur))) {
1259       dts = GST_BUFFER_DTS (cur);
1260     }
1261
1262     g = g_slist_next (g);
1263   }
1264
1265   if (distance)
1266     *distance = adapter->dts_distance + offset;
1267
1268   return dts;
1269 }
1270
1271 /**
1272  * gst_adapter_masked_scan_uint32_peek:
1273  * @adapter: a #GstAdapter
1274  * @mask: mask to apply to data before matching against @pattern
1275  * @pattern: pattern to match (after mask is applied)
1276  * @offset: offset into the adapter data from which to start scanning, returns
1277  *          the last scanned position.
1278  * @size: number of bytes to scan from offset
1279  * @value: (out) (allow-none): pointer to uint32 to return matching data
1280  *
1281  * Scan for pattern @pattern with applied mask @mask in the adapter data,
1282  * starting from offset @offset.  If a match is found, the value that matched
1283  * is returned through @value, otherwise @value is left untouched.
1284  *
1285  * The bytes in @pattern and @mask are interpreted left-to-right, regardless
1286  * of endianness.  All four bytes of the pattern must be present in the
1287  * adapter for it to match, even if the first or last bytes are masked out.
1288  *
1289  * It is an error to call this function without making sure that there is
1290  * enough data (offset+size bytes) in the adapter.
1291  *
1292  * Returns: offset of the first match, or -1 if no match was found.
1293  */
1294 gssize
1295 gst_adapter_masked_scan_uint32_peek (GstAdapter * adapter, guint32 mask,
1296     guint32 pattern, gsize offset, gsize size, guint32 * value)
1297 {
1298   GSList *g;
1299   gsize skip, bsize, i;
1300   guint32 state;
1301   GstMapInfo info;
1302   guint8 *bdata;
1303   GstBuffer *buf;
1304
1305   g_return_val_if_fail (size > 0, -1);
1306   g_return_val_if_fail (offset + size <= adapter->size, -1);
1307   g_return_val_if_fail (((~mask) & pattern) == 0, -1);
1308
1309   /* we can't find the pattern with less than 4 bytes */
1310   if (G_UNLIKELY (size < 4))
1311     return -1;
1312
1313   skip = offset + adapter->skip;
1314
1315   /* first step, do skipping and position on the first buffer */
1316   /* optimistically assume scanning continues sequentially */
1317   if (adapter->scan_entry && (adapter->scan_offset <= skip)) {
1318     g = adapter->scan_entry;
1319     skip -= adapter->scan_offset;
1320   } else {
1321     g = adapter->buflist;
1322     adapter->scan_offset = 0;
1323     adapter->scan_entry = NULL;
1324   }
1325   buf = g->data;
1326   bsize = gst_buffer_get_size (buf);
1327   while (G_UNLIKELY (skip >= bsize)) {
1328     skip -= bsize;
1329     g = g_slist_next (g);
1330     adapter->scan_offset += bsize;
1331     adapter->scan_entry = g;
1332     buf = g->data;
1333     bsize = gst_buffer_get_size (buf);
1334   }
1335   /* get the data now */
1336   if (!gst_buffer_map (buf, &info, GST_MAP_READ))
1337     return -1;
1338
1339   bdata = (guint8 *) info.data + skip;
1340   bsize = info.size - skip;
1341   skip = 0;
1342
1343   /* set the state to something that does not match */
1344   state = ~pattern;
1345
1346   /* now find data */
1347   do {
1348     bsize = MIN (bsize, size);
1349     for (i = 0; i < bsize; i++) {
1350       state = ((state << 8) | bdata[i]);
1351       if (G_UNLIKELY ((state & mask) == pattern)) {
1352         /* we have a match but we need to have skipped at
1353          * least 4 bytes to fill the state. */
1354         if (G_LIKELY (skip + i >= 3)) {
1355           if (G_LIKELY (value))
1356             *value = state;
1357           gst_buffer_unmap (buf, &info);
1358           return offset + skip + i - 3;
1359         }
1360       }
1361     }
1362     size -= bsize;
1363     if (size == 0)
1364       break;
1365
1366     /* nothing found yet, go to next buffer */
1367     skip += bsize;
1368     g = g_slist_next (g);
1369     adapter->scan_offset += info.size;
1370     adapter->scan_entry = g;
1371     gst_buffer_unmap (buf, &info);
1372     buf = g->data;
1373
1374     if (!gst_buffer_map (buf, &info, GST_MAP_READ))
1375       return -1;
1376
1377     bsize = info.size;
1378     bdata = info.data;
1379   } while (TRUE);
1380
1381   gst_buffer_unmap (buf, &info);
1382
1383   /* nothing found */
1384   return -1;
1385 }
1386
1387 /**
1388  * gst_adapter_masked_scan_uint32:
1389  * @adapter: a #GstAdapter
1390  * @mask: mask to apply to data before matching against @pattern
1391  * @pattern: pattern to match (after mask is applied)
1392  * @offset: offset into the adapter data from which to start scanning, returns
1393  *          the last scanned position.
1394  * @size: number of bytes to scan from offset
1395  *
1396  * Scan for pattern @pattern with applied mask @mask in the adapter data,
1397  * starting from offset @offset.
1398  *
1399  * The bytes in @pattern and @mask are interpreted left-to-right, regardless
1400  * of endianness.  All four bytes of the pattern must be present in the
1401  * adapter for it to match, even if the first or last bytes are masked out.
1402  *
1403  * It is an error to call this function without making sure that there is
1404  * enough data (offset+size bytes) in the adapter.
1405  *
1406  * This function calls gst_adapter_masked_scan_uint32_peek() passing %NULL
1407  * for value.
1408  *
1409  * Returns: offset of the first match, or -1 if no match was found.
1410  *
1411  * Example:
1412  * <programlisting>
1413  * // Assume the adapter contains 0x00 0x01 0x02 ... 0xfe 0xff
1414  *
1415  * gst_adapter_masked_scan_uint32 (adapter, 0xffffffff, 0x00010203, 0, 256);
1416  * // -> returns 0
1417  * gst_adapter_masked_scan_uint32 (adapter, 0xffffffff, 0x00010203, 1, 255);
1418  * // -> returns -1
1419  * gst_adapter_masked_scan_uint32 (adapter, 0xffffffff, 0x01020304, 1, 255);
1420  * // -> returns 1
1421  * gst_adapter_masked_scan_uint32 (adapter, 0xffff, 0x0001, 0, 256);
1422  * // -> returns -1
1423  * gst_adapter_masked_scan_uint32 (adapter, 0xffff, 0x0203, 0, 256);
1424  * // -> returns 0
1425  * gst_adapter_masked_scan_uint32 (adapter, 0xffff0000, 0x02030000, 0, 256);
1426  * // -> returns 2
1427  * gst_adapter_masked_scan_uint32 (adapter, 0xffff0000, 0x02030000, 0, 4);
1428  * // -> returns -1
1429  * </programlisting>
1430  */
1431 gssize
1432 gst_adapter_masked_scan_uint32 (GstAdapter * adapter, guint32 mask,
1433     guint32 pattern, gsize offset, gsize size)
1434 {
1435   return gst_adapter_masked_scan_uint32_peek (adapter, mask, pattern, offset,
1436       size, NULL);
1437 }