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