gst/elements/gstbufferstore.c

   1 /* GStreamer
   2  * Copyright (C) 2003 Benjamin Otte <in7y118@public.uni-hamburg.de>
   3  *
   4  * gstbufferstore.c: keep an easily accessible list of all buffers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #  include "config.h"
  24 #endif
  25 #include "gstbufferstore.h"
  26 #include <gst/gstutils.h>
  27 #include <string.h>
  28
  29 GST_DEBUG_CATEGORY_STATIC (gst_buffer_store_debug);
  30 #define GST_CAT_DEFAULT gst_buffer_store_debug
  31
  32 enum {
  33   CLEARED,
  34   BUFFER_ADDED,
  35   LAST_SIGNAL
  36 };
  37 enum {
  38   ARG_0
  39 };
  40
  41
  42 static void     gst_buffer_store_dispose        (GObject *              object);
  43
  44 static gboolean gst_buffer_store_add_buffer_func (GstBufferStore *      store,
  45                                                  GstBuffer *            buffer);
  46 static void     gst_buffer_store_cleared_func   (GstBufferStore *       store);
  47
  48 static guint gst_buffer_store_signals[LAST_SIGNAL] = { 0 };
  49
  50 GST_BOILERPLATE (GstBufferStore, gst_buffer_store, GObject, G_TYPE_OBJECT);
  51
  52
  53 G_GNUC_UNUSED static void
  54 debug_buffers (GstBufferStore *store)
  55 {
  56   GList *walk = store->buffers;
  57
  58   g_printerr ("BUFFERS in store:\n");
  59   while (walk) {
  60     g_print ("%15"G_GUINT64_FORMAT" - %7u\n", GST_BUFFER_OFFSET (walk->data), GST_BUFFER_SIZE (walk->data));
  61     walk = g_list_next (walk);
  62   }
  63   g_printerr ("\n");
  64 }
  65 static gboolean
  66 continue_accu (GSignalInvocationHint *ihint, GValue *return_accu,
  67                const GValue *handler_return, gpointer data)
  68 {
  69   gboolean do_continue = g_value_get_boolean (handler_return);
  70   g_value_set_boolean (return_accu, do_continue);
  71
  72   return do_continue;
  73 }
  74 static void
  75 gst_buffer_store_base_init (gpointer g_class)
  76 {
  77 }
  78 static void
  79 gst_buffer_store_class_init (GstBufferStoreClass *store_class)
  80 {
  81   GObjectClass *gobject_class = G_OBJECT_CLASS (store_class);
  82
  83   gobject_class->dispose = gst_buffer_store_dispose;
  84
  85   gst_buffer_store_signals[CLEARED] = g_signal_new ("cleared",
  86           G_TYPE_FROM_CLASS (store_class), G_SIGNAL_RUN_LAST,
  87           G_STRUCT_OFFSET (GstBufferStoreClass, cleared), NULL, NULL,
  88           gst_marshal_VOID__VOID, G_TYPE_NONE, 0);
  89   gst_buffer_store_signals[BUFFER_ADDED] = g_signal_new ("buffer-added",
  90           G_TYPE_FROM_CLASS (store_class), G_SIGNAL_RUN_LAST,
  91           G_STRUCT_OFFSET (GstBufferStoreClass, buffer_added), continue_accu, NULL,
  92           gst_marshal_BOOLEAN__POINTER, G_TYPE_BOOLEAN, 1, GST_TYPE_BUFFER);
  93
  94   store_class->cleared = gst_buffer_store_cleared_func;
  95   store_class->buffer_added = gst_buffer_store_add_buffer_func;
  96 }
  97 static void
  98 gst_buffer_store_init (GstBufferStore *store)
  99 {
 100   store->buffers = NULL;
 101 }
 102 static void
 103 gst_buffer_store_dispose (GObject *object)
 104 {
 105   GstBufferStore *store = GST_BUFFER_STORE (object);
 106
 107   gst_buffer_store_clear (store);
 108
 109   parent_class->dispose (object);
 110 }
 111 static gboolean
 112 gst_buffer_store_add_buffer_func (GstBufferStore *store, GstBuffer *buffer)
 113 {
 114   g_assert (buffer != NULL);
 115
 116   if (!GST_BUFFER_OFFSET_IS_VALID (buffer) &&
 117       store->buffers &&
 118       GST_BUFFER_OFFSET_IS_VALID (store->buffers->data)) {
 119     /* we assumed valid offsets, but suddenly they are not anymore */
 120     GST_DEBUG_OBJECT (store, "attempting to add buffer %p with invalid offset to store with valid offset, abort",
 121             buffer);
 122     return FALSE;
 123   } else if (!store->buffers || !GST_BUFFER_OFFSET_IS_VALID (store->buffers->data)) {
 124     /* the starting buffer had an invalid offset, in that case we assume continuous buffers */
 125     GST_LOG_OBJECT (store, "adding buffer %p with invalid offset and size %u",
 126             buffer, GST_BUFFER_SIZE (buffer));
 127     gst_data_ref (GST_DATA (buffer));
 128     store->buffers = g_list_append (store->buffers, buffer);
 129     return TRUE;
 130   } else {
 131     /* both list and buffer have valid offsets, we can really go wild */
 132     GList *walk, *current_list = NULL;
 133     GstBuffer *current;
 134
 135     g_assert (GST_BUFFER_OFFSET_IS_VALID (buffer));
 136     GST_LOG_OBJECT (store, "attempting to add buffer %p with offset %"G_GUINT64_FORMAT" and size %u",
 137             buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
 138     /* we keep a sorted list of non-overlapping buffers */
 139     walk = store->buffers;
 140     while (walk) {
 141       current = GST_BUFFER (walk->data);
 142       current_list = walk;
 143       walk = g_list_next (walk);
 144       if (GST_BUFFER_OFFSET (current) < GST_BUFFER_OFFSET (buffer)) {
 145         continue;
 146       } else if (GST_BUFFER_OFFSET (current) == GST_BUFFER_OFFSET (buffer)) {
 147         guint needed_size;
 148         if (walk) {
 149           needed_size = MIN (GST_BUFFER_SIZE (buffer),
 150                   GST_BUFFER_OFFSET (walk->data) - GST_BUFFER_OFFSET (current));
 151         } else {
 152           needed_size = GST_BUFFER_SIZE (buffer);
 153         }
 154         if (needed_size <= GST_BUFFER_SIZE (current)) {
 155           buffer = NULL;
 156           break;
 157         } else {
 158           if (needed_size < GST_BUFFER_SIZE (buffer)) {
 159             /* need to create subbuffer to not have overlapping data */
 160             GstBuffer *sub = gst_buffer_create_sub (buffer, 0, needed_size);
 161             g_assert (sub);
 162             buffer = sub;
 163           } else {
 164             gst_data_ref (GST_DATA (buffer));
 165           }
 166           /* replace current buffer with new one */
 167           GST_INFO_OBJECT (store, "replacing buffer %p with buffer %p with offset %"G_GINT64_FORMAT" and size %u",
 168                            current_list->data, buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
 169           gst_data_unref (GST_DATA (current_list->data));
 170           current_list->data = buffer;
 171           buffer = NULL;
 172           break;
 173         }
 174       } else if (GST_BUFFER_OFFSET (current) > GST_BUFFER_OFFSET (buffer)) {
 175         GList *previous = g_list_previous (current_list);
 176         guint64 start_offset = previous ?
 177                 GST_BUFFER_OFFSET (previous->data) + GST_BUFFER_SIZE (previous->data) : 0;
 178
 179         if (start_offset == GST_BUFFER_OFFSET (current)) {
 180           buffer = NULL;
 181           break;
 182         } else {
 183           /* we have data to insert */
 184           if (start_offset > GST_BUFFER_OFFSET (buffer) ||
 185               GST_BUFFER_OFFSET (buffer) + GST_BUFFER_SIZE (buffer) > GST_BUFFER_OFFSET (current)) {
 186             GstBuffer *sub;
 187
 188             /* need a subbuffer */
 189             start_offset = GST_BUFFER_OFFSET (buffer) > start_offset ? 0 :
 190                            start_offset - GST_BUFFER_OFFSET (buffer);
 191             sub = gst_buffer_create_sub (buffer, start_offset,
 192                     MIN (GST_BUFFER_SIZE (buffer), GST_BUFFER_OFFSET (current) - start_offset - GST_BUFFER_OFFSET (buffer)));
 193             g_assert (sub);
 194             GST_BUFFER_OFFSET (sub) = start_offset + GST_BUFFER_OFFSET (buffer);
 195             buffer = sub;
 196           } else {
 197             gst_data_ref (GST_DATA (buffer));
 198           }
 199           GST_INFO_OBJECT (store, "adding buffer %p with offset %"G_GINT64_FORMAT" and size %u",
 200                            buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
 201           store->buffers = g_list_insert_before (store->buffers, current_list, buffer);
 202           buffer = NULL;
 203           break;
 204         }
 205       }
 206     }
 207     if (buffer) {
 208       gst_data_ref (GST_DATA (buffer));
 209       GST_INFO_OBJECT (store, "adding buffer %p with offset %"G_GINT64_FORMAT" and size %u",
 210                        buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
 211       if (current_list) {
 212         g_list_append (current_list, buffer);
 213       } else {
 214         g_assert (store->buffers == NULL);
 215         store->buffers = g_list_prepend (NULL, buffer);
 216       }
 217     }
 218     return TRUE;
 219   }
 220 }
 221 static void
 222 gst_buffer_store_cleared_func (GstBufferStore *store)
 223 {
 224   g_list_foreach (store->buffers, (GFunc) gst_data_unref, NULL);
 225   g_list_free (store->buffers);
 226   store->buffers = NULL;
 227 }
 228 /**
 229  * gst_buffer_store_new:
 230  *
 231  * Creates a new bufferstore.
 232  *
 233  * Returns: the new bufferstore.
 234  */
 235 GstBufferStore *
 236 gst_buffer_store_new (void)
 237 {
 238   return GST_BUFFER_STORE (g_object_new (GST_TYPE_BUFFER_STORE, NULL));
 239 }
 240 /**
 241  * gst_buffer_store_clear:
 242  * @store: a bufferstore
 243  *
 244  * Clears the buffer store. All buffers are removed and the buffer store
 245  * behaves like it was just created.
 246  */
 247 /* FIXME: call this function _reset ? */
 248 void
 249 gst_buffer_store_clear (GstBufferStore *store)
 250 {
 251   g_return_if_fail (GST_IS_BUFFER_STORE (store));
 252
 253   g_signal_emit (store, gst_buffer_store_signals [CLEARED], 0, NULL);
 254 }
 255 /**
 256  * gst_buffer_store_add_buffer:
 257  * @store: a bufferstore
 258  * @buffer: the buffer to add
 259  *
 260  * Adds a buffer to the buffer store.
 261  *
 262  * Returns: TRUE, if the buffer was added, FALSE if an error occured.
 263  */
 264 gboolean
 265 gst_buffer_store_add_buffer (GstBufferStore *store, GstBuffer *buffer)
 266 {
 267   gboolean ret;
 268
 269   g_return_val_if_fail (GST_IS_BUFFER_STORE (store), FALSE);
 270   g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);
 271
 272   if (store->buffers &&
 273       GST_BUFFER_OFFSET_IS_VALID (store->buffers->data) &&
 274       !GST_BUFFER_OFFSET_IS_VALID (buffer))
 275     return FALSE;
 276
 277   g_signal_emit (store, gst_buffer_store_signals [BUFFER_ADDED], 0, buffer, &ret);
 278
 279   return ret;
 280 }
 281 /**
 282  * gst_buffer_store_get_buffer:
 283  * @store: a bufferstore
 284  * @offset: starting offset of returned buffer
 285  * @size: size of returned buffer
 286  *
 287  * Returns a buffer that corresponds to the given area of data. If part of the
 288  * data is not available inside the store, NULL is returned. You have to unref
 289  * the buffer after use.
 290  *
 291  * Returns: a buffer with the requested data or NULL if the data was not
 292  *          available.
 293  */
 294 GstBuffer *
 295 gst_buffer_store_get_buffer (GstBufferStore *store, guint64 offset, guint size)
 296 {
 297   GstBuffer *current;
 298   GList *walk;
 299   guint8 *data;
 300   guint tmp;
 301   gboolean have_offset;
 302   guint64 cur_offset = 0;
 303   GstBuffer *ret = NULL;
 304
 305   g_return_val_if_fail (GST_IS_BUFFER_STORE (store), NULL);
 306
 307   walk = store->buffers;
 308   if (!walk)
 309     return NULL;
 310   if (GST_BUFFER_OFFSET_IS_VALID (walk->data)) {
 311     have_offset = TRUE;
 312   } else {
 313     have_offset = FALSE;
 314   }
 315   while (walk) {
 316     current = GST_BUFFER (walk->data);
 317     if (have_offset) {
 318       cur_offset = GST_BUFFER_OFFSET (current);
 319     }
 320     walk = g_list_next (walk);
 321     if (cur_offset > offset) {
 322       /* #include <windows.h>
 323          do_nothing_loop (); */
 324     } else if (cur_offset == offset &&
 325         GST_BUFFER_SIZE (current) == size) {
 326       GST_LOG_OBJECT (store, "found matching buffer %p for offset %"G_GUINT64_FORMAT" and size %u",
 327                       current, offset, size);
 328       ret = current;
 329       gst_data_ref (GST_DATA (ret));
 330       GST_LOG_OBJECT (store, "refcount %d",
 331                       GST_DATA_REFCOUNT_VALUE(ret));
 332       break;
 333     } else if (cur_offset + GST_BUFFER_SIZE (current) > offset) {
 334       if (cur_offset + GST_BUFFER_SIZE (current) >= offset + size) {
 335         ret = gst_buffer_create_sub (current, offset - cur_offset, size);
 336         GST_LOG_OBJECT (store, "created subbuffer %p from buffer %p for offset %llu and size %u",
 337                         ret, current,  offset, size);
 338         break;
 339       }
 340       /* uh, the requested data spans some buffers */
 341       ret = gst_buffer_new_and_alloc (size);
 342       GST_LOG_OBJECT (store, "created buffer %p for offset %"G_GUINT64_FORMAT
 343                       " and size %u, will fill with data now",
 344                       ret, offset, size);
 345       data = GST_BUFFER_DATA (ret);
 346       tmp = GST_BUFFER_SIZE (current) - offset + cur_offset;
 347       memcpy (data, GST_BUFFER_DATA (current) + offset - cur_offset, tmp);
 348       data += tmp;
 349       size -= tmp;
 350       while (size) {
 351         if (walk == NULL ||
 352             (have_offset &&
 353              GST_BUFFER_OFFSET (current) + GST_BUFFER_SIZE (current) != GST_BUFFER_OFFSET (walk->data))) {
 354           GST_DEBUG_OBJECT (store, "not all data for offset %"G_GUINT64_FORMAT" and remaining size %u available, aborting",
 355                             offset, size);
 356           gst_data_unref (GST_DATA (ret));
 357           ret = NULL;
 358           goto out;
 359         }
 360         current = GST_BUFFER (walk->data);
 361         walk = g_list_next (walk);
 362         tmp = MIN (GST_BUFFER_SIZE (current), size);
 363         memcpy (data, GST_BUFFER_DATA (current), tmp);
 364         size -= tmp;
 365       }
 366     }
 367     if (!have_offset) {
 368       cur_offset += GST_BUFFER_SIZE (current);
 369     }
 370   }
 371 out:
 372
 373   return ret;
 374 }
 375 /**
 376  * gst_buffer_store_get_size:
 377  * @store: a bufferstore
 378  * @offset: desired offset
 379  *
 380  * Calculates the number of bytes available starting from offset. This allows
 381  * to query a buffer with the returned size.
 382  *
 383  * Returns: the number of continuous bytes in the bufferstore starting at
 384  *          offset.
 385  */
 386 guint
 387 gst_buffer_store_get_size (GstBufferStore *store, guint64 offset)
 388 {
 389   GList *walk;
 390   gboolean have_offset;
 391   gboolean counting = FALSE;
 392   guint64 cur_offset = 0;
 393   GstBuffer *current = NULL;
 394   guint ret = 0;
 395
 396   g_return_val_if_fail (GST_IS_BUFFER_STORE (store), 0);
 397
 398   walk = store->buffers;
 399   if (!walk)
 400     return 0;
 401   if (GST_BUFFER_OFFSET_IS_VALID (walk->data)) {
 402     have_offset = TRUE;
 403   } else {
 404     have_offset = FALSE;
 405   }
 406   while (walk) {
 407     if (have_offset && counting &&
 408         cur_offset + GST_BUFFER_SIZE (current) !=  GST_BUFFER_OFFSET (walk->data)) {
 409       break;
 410     }
 411     current = GST_BUFFER (walk->data);
 412     if (have_offset) {
 413       cur_offset = GST_BUFFER_OFFSET (current);
 414     }
 415     walk = g_list_next (walk);
 416     if (counting) {
 417       ret += GST_BUFFER_SIZE (current);
 418     } else {
 419       if (cur_offset > offset)
 420         return 0;
 421       if (cur_offset + GST_BUFFER_SIZE (current) > offset) {
 422         /* we have at least some bytes */
 423         ret = cur_offset + GST_BUFFER_SIZE (current) - offset;
 424         counting = TRUE;
 425       }
 426     }
 427     if (!have_offset) {
 428       cur_offset += GST_BUFFER_SIZE (current);
 429     }
 430   }
 431
 432   return ret;
 433 }