tests/check/gst/gstbuffer.c

   1 /* GStreamer
   2  *
   3  * unit test for GstBuffer
   4  *
   5  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #ifdef HAVE_VALGRIND_H
  28 # include <valgrind/valgrind.h>
  29 #else
  30 # define RUNNING_ON_VALGRIND FALSE
  31 #endif
  32
  33 #include <gst/check/gstcheck.h>
  34
  35 GST_START_TEST (test_subbuffer)
  36 {
  37   GstBuffer *buffer, *sub;
  38   GstMapInfo info, sinfo;
  39
  40   buffer = gst_buffer_new_and_alloc (4);
  41
  42   /* check sizes, buffer starts out empty */
  43   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_WRITE));
  44   fail_unless (info.size == 4, "buffer has wrong size");
  45   fail_unless (info.maxsize >= 4, "buffer has wrong size");
  46   memset (info.data, 0, 4);
  47   gst_buffer_unmap (buffer, &info);
  48
  49   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
  50   /* set some metadata */
  51   GST_BUFFER_TIMESTAMP (buffer) = 1;
  52   GST_BUFFER_DURATION (buffer) = 2;
  53   GST_BUFFER_OFFSET (buffer) = 3;
  54   GST_BUFFER_OFFSET_END (buffer) = 4;
  55
  56   sub = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 1, 2);
  57   fail_if (sub == NULL, "copy region of buffer returned NULL");
  58
  59   fail_unless (gst_buffer_map (sub, &sinfo, GST_MAP_READ));
  60   fail_unless (sinfo.size == 2, "subbuffer has wrong size");
  61   fail_unless (memcmp (info.data + 1, sinfo.data, 2) == 0,
  62       "subbuffer contains the wrong data");
  63   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
  64   fail_unless (GST_BUFFER_TIMESTAMP (sub) == -1,
  65       "subbuffer has wrong timestamp");
  66   fail_unless (GST_BUFFER_DURATION (sub) == -1, "subbuffer has wrong duration");
  67   fail_unless (GST_BUFFER_OFFSET (sub) == -1, "subbuffer has wrong offset");
  68   fail_unless (GST_BUFFER_OFFSET_END (sub) == -1,
  69       "subbuffer has wrong offset end");
  70   gst_buffer_unmap (sub, &sinfo);
  71   gst_buffer_unref (sub);
  72
  73   /* create a subbuffer of size 0 */
  74   sub = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 1, 0);
  75   fail_if (sub == NULL, "copy_region of buffer returned NULL");
  76   fail_unless (gst_buffer_map (sub, &sinfo, GST_MAP_READ));
  77   fail_unless (sinfo.size == 0, "subbuffer has wrong size");
  78   fail_unless (memcmp (info.data + 1, sinfo.data, 0) == 0,
  79       "subbuffer contains the wrong data");
  80   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
  81   gst_buffer_unmap (sub, &sinfo);
  82   gst_buffer_unref (sub);
  83
  84   /* test if metadata is coppied, not a complete buffer copy so only the
  85    * timestamp and offset fields are copied. */
  86   sub = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 0, 1);
  87   fail_if (sub == NULL, "copy_region of buffer returned NULL");
  88   fail_unless (gst_buffer_get_size (sub) == 1, "subbuffer has wrong size");
  89   fail_unless (GST_BUFFER_TIMESTAMP (sub) == 1,
  90       "subbuffer has wrong timestamp");
  91   fail_unless (GST_BUFFER_OFFSET (sub) == 3, "subbuffer has wrong offset");
  92   fail_unless (GST_BUFFER_DURATION (sub) == -1, "subbuffer has wrong duration");
  93   fail_unless (GST_BUFFER_OFFSET_END (sub) == -1,
  94       "subbuffer has wrong offset end");
  95   gst_buffer_unref (sub);
  96
  97   /* test if metadata is coppied, a complete buffer is copied so all the timing
  98    * fields should be copied. */
  99   sub = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 0, 4);
 100   fail_if (sub == NULL, "copy_region of buffer returned NULL");
 101   fail_unless (gst_buffer_get_size (sub) == 4, "subbuffer has wrong size");
 102   fail_unless (GST_BUFFER_TIMESTAMP (sub) == 1,
 103       "subbuffer has wrong timestamp");
 104   fail_unless (GST_BUFFER_DURATION (sub) == 2, "subbuffer has wrong duration");
 105   fail_unless (GST_BUFFER_OFFSET (sub) == 3, "subbuffer has wrong offset");
 106   fail_unless (GST_BUFFER_OFFSET_END (sub) == 4,
 107       "subbuffer has wrong offset end");
 108
 109   /* clean up */
 110   gst_buffer_unref (sub);
 111
 112   gst_buffer_unmap (buffer, &info);
 113   gst_buffer_unref (buffer);
 114 }
 115
 116 GST_END_TEST;
 117
 118 GST_START_TEST (test_span)
 119 {
 120   GstBuffer *buffer, *sub1, *sub2, *span;
 121   GstMapInfo info;
 122
 123   buffer = gst_buffer_new_and_alloc (4);
 124
 125   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_WRITE));
 126   memcpy (info.data, "data", 4);
 127   gst_buffer_unmap (buffer, &info);
 128
 129   ASSERT_CRITICAL (gst_buffer_append (NULL, NULL));
 130   ASSERT_CRITICAL (gst_buffer_append (buffer, NULL));
 131   ASSERT_CRITICAL (gst_buffer_append (NULL, buffer));
 132
 133   sub1 = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 0, 2);
 134   fail_if (sub1 == NULL, "copy_region of buffer returned NULL");
 135
 136   sub2 = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 2, 2);
 137   fail_if (sub2 == NULL, "copy_region of buffer returned NULL");
 138
 139   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 140   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 141   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 142
 143   /* span will create a new subbuffer from the parent */
 144   gst_buffer_ref (sub1);
 145   gst_buffer_ref (sub2);
 146   span = gst_buffer_append (sub1, sub2);
 147   fail_unless (gst_buffer_map (span, &info, GST_MAP_READ));
 148   fail_unless (info.size == 4, "spanned buffer is wrong size");
 149   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 150   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 151   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 152   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 153   fail_unless (memcmp (info.data, "data", 4) == 0,
 154       "spanned buffer contains the wrong data");
 155   gst_buffer_unmap (span, &info);
 156   gst_buffer_unref (span);
 157   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 158
 159   /* span from non-contiguous buffers will create new buffers */
 160   gst_buffer_ref (sub1);
 161   gst_buffer_ref (sub2);
 162   span = gst_buffer_append (sub2, sub1);
 163   fail_unless (gst_buffer_map (span, &info, GST_MAP_READ));
 164   fail_unless (info.size == 4, "spanned buffer is wrong size");
 165   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 166   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 167   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 168   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 169   fail_unless (memcmp (info.data, "tada", 4) == 0,
 170       "spanned buffer contains the wrong data");
 171   gst_buffer_unmap (span, &info);
 172   gst_buffer_unref (span);
 173   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 174
 175   /* clean up */
 176   gst_buffer_unref (sub1);
 177   gst_buffer_unref (sub2);
 178   gst_buffer_unref (buffer);
 179 }
 180
 181 GST_END_TEST;
 182
 183
 184 static const char ro_memory[] = "abcdefghijklmnopqrstuvwxyz";
 185
 186 static GstBuffer *
 187 create_read_only_buffer (void)
 188 {
 189   GstBuffer *buf;
 190
 191   buf = gst_buffer_new ();
 192
 193   /* assign some read-only data to the new buffer */
 194   gst_buffer_insert_memory (buf, -1,
 195       gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY,
 196           (gpointer) ro_memory, sizeof (ro_memory),
 197           0, sizeof (ro_memory), NULL, NULL));
 198
 199   return buf;
 200 }
 201
 202 GST_START_TEST (test_make_writable)
 203 {
 204   GstBuffer *buf, *buf2;
 205   GstMapInfo info;
 206
 207   /* create read-only buffer and make it writable */
 208   buf = create_read_only_buffer ();
 209
 210   fail_unless (gst_buffer_map (buf, &info, GST_MAP_WRITE));
 211   info.data[4] = 'a';
 212   gst_buffer_unmap (buf, &info);
 213   gst_buffer_unref (buf);
 214
 215   /* alloc'ed buffer with refcount 1 should be writable */
 216   buf = gst_buffer_new_and_alloc (32);
 217   buf2 = gst_buffer_make_writable (buf);
 218   fail_unless (buf == buf2,
 219       "_make_writable() should have returned same buffer");
 220   gst_buffer_unref (buf2);
 221
 222   /* alloc'ed buffer with refcount >1 should be copied */
 223   buf = gst_buffer_new_and_alloc (32);
 224   gst_buffer_ref (buf);
 225   buf2 = gst_buffer_make_writable (buf);
 226   fail_unless (buf != buf2, "_make_writable() should have returned a copy!");
 227   gst_buffer_unref (buf2);
 228   gst_buffer_unref (buf);
 229 }
 230
 231 GST_END_TEST;
 232
 233 GST_START_TEST (test_subbuffer_make_writable)
 234 {
 235   GstBuffer *buf, *sub_buf;
 236   GstMapInfo info;
 237
 238   /* create sub-buffer of read-only buffer and make it writable */
 239   buf = create_read_only_buffer ();
 240
 241   sub_buf = gst_buffer_copy_region (buf, GST_BUFFER_COPY_ALL, 0, 8);
 242
 243   fail_unless (gst_buffer_map (sub_buf, &info, GST_MAP_WRITE));
 244   fail_if (info.data == NULL);
 245   info.data[4] = 'a';
 246   gst_buffer_unmap (sub_buf, &info);
 247   gst_buffer_unref (sub_buf);
 248   gst_buffer_unref (buf);
 249 }
 250
 251 GST_END_TEST;
 252
 253 GST_START_TEST (test_metadata_writable)
 254 {
 255   GstBuffer *buffer, *sub1;
 256
 257   buffer = gst_buffer_new_and_alloc (4);
 258   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
 259   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
 260
 261   /* Buffer with refcount 1 should have writable metadata */
 262   fail_unless (gst_buffer_is_writable (buffer) == TRUE);
 263
 264   /* Check that a buffer with refcount 2 does not have writable metadata */
 265   gst_buffer_ref (buffer);
 266   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2);
 267   fail_unless (gst_buffer_is_writable (buffer) == FALSE);
 268
 269   /* Check that make_metadata_writable produces a new sub-buffer with
 270    * writable metadata. */
 271   sub1 = gst_buffer_make_writable (buffer);
 272   fail_if (sub1 == buffer);
 273   fail_unless (gst_buffer_is_writable (sub1) == TRUE);
 274
 275   /* Check that make_metadata_writable() maintains the buffer flags */
 276   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DISCONT));
 277   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DELTA_UNIT));
 278
 279   /* Unset flags on writable buffer, then make sure they're still
 280    * set on the original buffer */
 281   GST_BUFFER_FLAG_UNSET (sub1, GST_BUFFER_FLAG_DISCONT);
 282   GST_BUFFER_FLAG_UNSET (sub1, GST_BUFFER_FLAG_DELTA_UNIT);
 283   fail_unless (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT));
 284   fail_unless (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT));
 285
 286   /* Drop the subbuffer and check that the metadata is now writable again */
 287   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 288   gst_buffer_unref (sub1);
 289   fail_unless (gst_buffer_is_writable (buffer) == TRUE);
 290
 291   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 292   gst_buffer_unref (buffer);
 293 }
 294
 295 GST_END_TEST;
 296
 297 GST_START_TEST (test_memcmp)
 298 {
 299   GstBuffer *buffer;
 300   char buf[3] = { 0, 0, 0 };
 301
 302   buffer = gst_buffer_new_and_alloc (2);
 303   gst_buffer_memset (buffer, 0, 0, 2);
 304
 305   fail_unless (gst_buffer_memcmp (buffer, 0, buf, 2) == 0);
 306   fail_unless (gst_buffer_memcmp (buffer, 0, buf, 1) == 0);
 307   fail_unless (gst_buffer_memcmp (buffer, 1, buf, 1) == 0);
 308   fail_unless (gst_buffer_memcmp (buffer, 0, buf, 3) != 0);
 309   fail_unless (gst_buffer_memcmp (buffer, 2, buf, 1) != 0);
 310   fail_unless (gst_buffer_memcmp (buffer, 4, buf, 1) != 0);
 311
 312   gst_buffer_memset (buffer, 0, 0x20, 2);
 313   fail_unless (gst_buffer_memcmp (buffer, 0, buf, 2) != 0);
 314   fail_unless (gst_buffer_memcmp (buffer, 0, buf, 1) != 0);
 315   fail_unless (gst_buffer_memcmp (buffer, 1, buf, 1) != 0);
 316   fail_unless (gst_buffer_memcmp (buffer, 0, buf, 3) != 0);
 317   fail_unless (gst_buffer_memcmp (buffer, 2, buf, 1) != 0);
 318
 319   gst_buffer_unref (buffer);
 320 }
 321
 322 GST_END_TEST;
 323
 324 GST_START_TEST (test_copy)
 325 {
 326   GstBuffer *buffer, *copy;
 327   GstMapInfo info, sinfo;
 328
 329   buffer = gst_buffer_new_and_alloc (4);
 330   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 331
 332   copy = gst_buffer_copy (buffer);
 333   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 334   ASSERT_BUFFER_REFCOUNT (copy, "copy", 1);
 335   /* buffers are copied and must point to different memory */
 336   fail_if (buffer == copy);
 337
 338   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
 339   fail_unless (gst_buffer_map (copy, &sinfo, GST_MAP_READ));
 340
 341   /* NOTE that data is refcounted */
 342   fail_unless (info.size == sinfo.size);
 343   /* GstBuffer was copied but the underlying GstMemory should be the same */
 344   fail_unless (info.data == sinfo.data);
 345
 346   gst_buffer_unmap (copy, &sinfo);
 347   gst_buffer_unmap (buffer, &info);
 348
 349   gst_buffer_unref (copy);
 350   gst_buffer_unref (buffer);
 351
 352   /* a 0-sized buffer has NULL data as per docs */
 353   buffer = gst_buffer_new_and_alloc (0);
 354   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
 355   fail_unless (info.data == NULL);
 356   gst_buffer_unmap (buffer, &info);
 357
 358   /* copying a 0-sized buffer should not crash and also set
 359    * the data member NULL. */
 360   copy = gst_buffer_copy (buffer);
 361   fail_unless (gst_buffer_map (copy, &info, GST_MAP_READ));
 362   fail_unless (info.data == NULL);
 363   gst_buffer_unmap (copy, &info);
 364
 365   gst_buffer_unref (copy);
 366   gst_buffer_unref (buffer);
 367
 368   /* check if copy is an independent copy when written to */
 369   buffer = gst_buffer_new_and_alloc (4);
 370   gst_buffer_memset (buffer, 0, 0, 4);
 371   copy = gst_buffer_copy (buffer);
 372   fail_unless (gst_buffer_is_writable (copy));
 373   gst_buffer_memset (copy, 0, 0x80, 4);
 374   gst_buffer_map (buffer, &info, GST_MAP_READ);
 375   fail_if (gst_buffer_memcmp (copy, 0, info.data, info.size) == 0);
 376   gst_buffer_unmap (buffer, &info);
 377
 378   gst_buffer_unref (copy);
 379   gst_buffer_unref (buffer);
 380
 381   /* copy should still be independent if copied when mapped */
 382   buffer = gst_buffer_new_and_alloc (4);
 383   gst_buffer_memset (buffer, 0, 0, 4);
 384   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_WRITE));
 385   copy = gst_buffer_copy (buffer);
 386   fail_unless (gst_buffer_is_writable (copy));
 387   gst_buffer_memset (copy, 0, 0x80, 4);
 388   gst_buffer_unmap (buffer, &info);
 389   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
 390   fail_if (gst_buffer_memcmp (copy, 0, info.data, info.size) == 0);
 391   gst_buffer_unmap (buffer, &info);
 392
 393   gst_buffer_unref (copy);
 394   gst_buffer_unref (buffer);
 395
 396   /* check if a writable clone of a buffer is independent when written to */
 397   buffer = gst_buffer_new_and_alloc (4);
 398   gst_buffer_memset (buffer, 0, 0, 4);
 399   copy = gst_buffer_ref (buffer);
 400   copy = gst_buffer_make_writable (copy);
 401   fail_unless (gst_buffer_is_writable (copy));
 402   gst_buffer_memset (copy, 0, 0x80, 4);
 403   gst_buffer_map (buffer, &info, GST_MAP_READ);
 404   fail_if (gst_buffer_memcmp (copy, 0, info.data, info.size) == 0);
 405   gst_buffer_unmap (buffer, &info);
 406
 407   gst_buffer_unref (copy);
 408   gst_buffer_unref (buffer);
 409 }
 410
 411 GST_END_TEST;
 412
 413 GST_START_TEST (test_copy_deep)
 414 {
 415   GstBuffer *buffer, *copy;
 416   GstMapInfo info, sinfo;
 417
 418   buffer = gst_buffer_new_and_alloc (4);
 419   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 420
 421   copy = gst_buffer_copy_deep (buffer);
 422   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 423   ASSERT_BUFFER_REFCOUNT (copy, "copy", 1);
 424   /* buffers are copied and must point to different memory */
 425   fail_if (buffer == copy);
 426
 427   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
 428   fail_unless (gst_buffer_map (copy, &sinfo, GST_MAP_READ));
 429
 430   /* NOTE that data is refcounted */
 431   fail_unless (info.size == sinfo.size);
 432   /* copy_deep() forces new GstMemory to be used */
 433   fail_unless (info.data != sinfo.data);
 434
 435   gst_buffer_unmap (copy, &sinfo);
 436   gst_buffer_unmap (buffer, &info);
 437
 438   gst_buffer_unref (copy);
 439   gst_buffer_unref (buffer);
 440 }
 441
 442 GST_END_TEST;
 443
 444 GST_START_TEST (test_try_new_and_alloc)
 445 {
 446   GstBuffer *buf;
 447   GstMapInfo info;
 448
 449   /* special case: alloc of 0 bytes results in new buffer with NULL data */
 450   buf = gst_buffer_new_and_alloc (0);
 451   fail_unless (buf != NULL);
 452   fail_unless (GST_IS_BUFFER (buf));
 453   fail_unless (gst_buffer_map (buf, &info, GST_MAP_READ));
 454   fail_unless (info.data == NULL);
 455   gst_buffer_unmap (buf, &info);
 456   gst_buffer_unref (buf);
 457
 458   /* normal alloc should still work */
 459   buf = gst_buffer_new_and_alloc (640 * 480 * 4);
 460   fail_unless (buf != NULL);
 461   fail_unless (GST_IS_BUFFER (buf));
 462   fail_unless (gst_buffer_map (buf, &info, GST_MAP_WRITE));
 463   fail_unless (info.data != NULL);
 464   fail_unless (info.size == (640 * 480 * 4));
 465   info.data[640 * 479 * 4 + 479] = 0xff;
 466   gst_buffer_unmap (buf, &info);
 467
 468   gst_buffer_unref (buf);
 469
 470 #if 0
 471   /* Disabled this part of the test, because it happily succeeds on 64-bit
 472    * machines that have enough memory+swap, because the address space is large
 473    * enough. There's not really any way to test the failure case except by
 474    * allocating chunks of memory until it fails, which would suck. */
 475
 476   /* now this better fail (don't run in valgrind, it will abort
 477    * or warn when passing silly arguments to malloc) */
 478   if (!RUNNING_ON_VALGRIND) {
 479     buf = gst_buffer_new_and_alloc ((guint) - 1);
 480     fail_unless (buf == NULL);
 481   }
 482 #endif
 483 }
 484
 485 GST_END_TEST;
 486
 487 GST_START_TEST (test_size)
 488 {
 489   GstBuffer *buf;
 490   GstMemory *mem;
 491   gsize maxalloc, maxalloc2, maxalloc3, maxalloc4;
 492   gsize size, maxsize, offset;
 493
 494   /* one memory block */
 495   buf = gst_buffer_new_allocate (NULL, 100, NULL);
 496
 497   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 498   fail_unless (size == 100);
 499   fail_unless (offset == 0);
 500   fail_unless (maxalloc >= 100);
 501
 502   mem = gst_buffer_get_memory (buf, 0);
 503   gst_memory_resize (mem, 10, 70);
 504   gst_memory_unref (mem);
 505
 506   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 507   fail_unless (size == 70);
 508   fail_unless (offset == 10);
 509   fail_unless (maxsize == maxalloc);
 510
 511   /* new memory */
 512   mem = gst_allocator_alloc (NULL, 100, NULL);
 513   size = gst_memory_get_sizes (mem, &offset, &maxalloc2);
 514   fail_unless (size == 100);
 515   fail_unless (offset == 0);
 516   fail_unless (maxalloc2 >= 100);
 517
 518   gst_memory_resize (mem, 20, 60);
 519   size = gst_memory_get_sizes (mem, &offset, &maxsize);
 520   fail_unless (size == 60);
 521   fail_unless (offset == 20);
 522   fail_unless (maxsize == maxalloc2);
 523
 524   /* append */
 525   gst_buffer_insert_memory (buf, -1, mem);
 526
 527   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 528   fail_unless (size == 130);
 529   fail_unless (offset == 10);
 530   /* the maxsize is the size of the first buffer plus the remaining size in the
 531    * second buffer */
 532   fail_unless (maxalloc == 80 + (maxalloc2 - 20));
 533
 534   /* appending an empty block */
 535   mem = gst_allocator_alloc (NULL, 100, NULL);
 536   size = gst_memory_get_sizes (mem, &offset, &maxalloc3);
 537   gst_memory_resize (mem, 0, 0);
 538   gst_buffer_insert_memory (buf, -1, mem);
 539
 540   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 541   fail_unless (size == 130);
 542   fail_unless (offset == 10);
 543   /* the maxsize is the size of the first buffer plus the remaining size in the
 544    * second buffer and the last empty buffer*/
 545   fail_unless (maxalloc == 80 + (maxalloc2 - 20) + maxalloc3);
 546
 547   /* prepending an empty block */
 548   mem = gst_allocator_alloc (NULL, 100, NULL);
 549   size = gst_memory_get_sizes (mem, &offset, &maxalloc4);
 550   gst_memory_resize (mem, 0, 0);
 551   gst_buffer_insert_memory (buf, 0, mem);
 552
 553   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 554   fail_unless (size == 130);
 555   /* empty buffer maxsize can be used as offset */
 556   fail_unless (offset == 10 + maxalloc4);
 557   /* the maxsize is the size of the first buffer plus the remaining size in the
 558    * second buffer and the last empty buffer*/
 559   fail_unless (maxalloc == 80 + (maxalloc2 - 20) + maxalloc3 + maxalloc4);
 560
 561   gst_buffer_unref (buf);
 562 }
 563
 564 GST_END_TEST;
 565
 566 GST_START_TEST (test_resize)
 567 {
 568   GstBuffer *buf;
 569   gsize maxalloc;
 570   gsize size, maxsize, offset;
 571
 572   /* one memory block */
 573   buf = gst_buffer_new_allocate (NULL, 100, NULL);
 574
 575   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 576   fail_unless (size == 100);
 577   fail_unless (offset == 0);
 578   fail_unless (maxalloc >= 100);
 579
 580   ASSERT_CRITICAL (gst_buffer_resize (buf, 200, 50));
 581   ASSERT_CRITICAL (gst_buffer_resize (buf, 0, 150));
 582   ASSERT_CRITICAL (gst_buffer_resize (buf, 1, maxalloc));
 583   ASSERT_CRITICAL (gst_buffer_resize (buf, maxalloc, 1));
 584
 585   /* this does nothing */
 586   gst_buffer_resize (buf, 0, 100);
 587
 588   /* nothing should have changed */
 589   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 590   fail_unless (size == 100);
 591   fail_unless (offset == 0);
 592   fail_unless (maxsize == maxalloc);
 593
 594   gst_buffer_resize (buf, 0, 50);
 595   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 596   fail_unless (size == 50);
 597   fail_unless (offset == 0);
 598   fail_unless (maxsize == maxalloc);
 599
 600   gst_buffer_resize (buf, 0, 100);
 601   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 602   fail_unless (size == 100);
 603   fail_unless (offset == 0);
 604   fail_unless (maxsize == maxalloc);
 605
 606   gst_buffer_resize (buf, 1, 99);
 607   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 608   fail_unless (size == 99);
 609   fail_unless (offset == 1);
 610   fail_unless (maxsize == maxalloc);
 611
 612   ASSERT_CRITICAL (gst_buffer_resize (buf, 1, maxalloc - 1));
 613
 614   gst_buffer_resize (buf, 0, 99);
 615   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 616   fail_unless (size == 99);
 617   fail_unless (offset == 1);
 618   fail_unless (maxsize == maxalloc);
 619
 620   gst_buffer_resize (buf, -1, 100);
 621   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 622   fail_unless (size == 100);
 623   fail_unless (offset == 0);
 624   fail_unless (maxsize == maxalloc);
 625
 626   ASSERT_CRITICAL (gst_buffer_resize (buf, -1, 100));
 627
 628   gst_buffer_resize (buf, 50, 40);
 629   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 630   fail_unless (size == 40);
 631   fail_unless (offset == 50);
 632   fail_unless (maxsize == maxalloc);
 633
 634   gst_buffer_resize (buf, -50, 100);
 635   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 636   fail_unless (size == 100);
 637   fail_unless (offset == 0);
 638   fail_unless (maxsize == maxalloc);
 639
 640   gst_buffer_resize (buf, 0, 0);
 641   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 642   fail_unless (size == 0);
 643   fail_unless (offset == 0);
 644   fail_unless (maxsize == maxalloc);
 645
 646   gst_buffer_resize (buf, 0, 100);
 647   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 648   fail_unless (size == 100);
 649   fail_unless (offset == 0);
 650   fail_unless (maxsize == maxalloc);
 651
 652   gst_buffer_resize (buf, 0, 100);
 653   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 654   fail_unless (size == 100);
 655   fail_unless (offset == 0);
 656   fail_unless (maxsize == maxalloc);
 657
 658   gst_buffer_unref (buf);
 659 }
 660
 661 GST_END_TEST;
 662
 663 GST_START_TEST (test_map)
 664 {
 665   GstBuffer *buf;
 666   GstMapInfo map, map2;
 667   gsize maxalloc;
 668   gsize size, offset;
 669
 670   buf = gst_buffer_new ();
 671   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 672   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 673
 674   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 675   fail_unless (size == 100);
 676   fail_unless (offset == 0);
 677   fail_unless (maxalloc >= 100);
 678   fail_unless (gst_buffer_n_memory (buf) == 2);
 679
 680   /* make readonly */
 681   gst_buffer_ref (buf);
 682   /* map should merge */
 683   gst_buffer_map (buf, &map, GST_MAP_READ);
 684   /* merged memory is not stored */
 685   fail_unless (gst_buffer_n_memory (buf) == 2);
 686   gst_buffer_unmap (buf, &map);
 687
 688   fail_unless (gst_buffer_n_memory (buf) == 2);
 689
 690   /* can't map write on readonly buffer */
 691   ASSERT_CRITICAL (gst_buffer_map (buf, &map, GST_MAP_WRITE));
 692   /* make writable again */
 693   gst_buffer_unref (buf);
 694
 695   /* should merge and store */
 696   gst_buffer_map (buf, &map, GST_MAP_READ);
 697   fail_unless (gst_buffer_n_memory (buf) == 1);
 698   gst_buffer_unmap (buf, &map);
 699
 700   gst_buffer_map (buf, &map, GST_MAP_WRITE);
 701   gst_buffer_unmap (buf, &map);
 702
 703   /* mapping same kind should be ok using same memory */
 704   gst_buffer_map (buf, &map, GST_MAP_WRITE);
 705   fail_unless (gst_buffer_map (buf, &map2, GST_MAP_WRITE));
 706   fail_unless (map.memory == map2.memory);
 707   gst_buffer_unmap (buf, &map2);
 708   gst_buffer_unmap (buf, &map);
 709
 710   /* ... but different kind should give temporary memory */
 711   gst_buffer_map (buf, &map, GST_MAP_WRITE);
 712   fail_unless (gst_buffer_map (buf, &map2, GST_MAP_READ));
 713   fail_if (map.memory == map2.memory);
 714   gst_buffer_unmap (buf, &map2);
 715   gst_buffer_unmap (buf, &map);
 716
 717   gst_buffer_unref (buf);
 718 }
 719
 720 GST_END_TEST;
 721
 722 GST_START_TEST (test_map_range)
 723 {
 724   GstBuffer *buf;
 725   GstMapInfo map;
 726   gsize maxalloc;
 727   gsize size, offset;
 728
 729   buf = gst_buffer_new ();
 730   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 731   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 732   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 733
 734   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 735   fail_unless (size == 150);
 736   fail_unless (offset == 0);
 737   fail_unless (maxalloc >= 150);
 738   fail_unless (gst_buffer_n_memory (buf) == 3);
 739
 740   gst_buffer_ref (buf);
 741   /* map should merge */
 742   gst_buffer_map_range (buf, 1, 2, &map, GST_MAP_READ);
 743   /* merged memory is not stored */
 744   fail_unless (gst_buffer_n_memory (buf) == 3);
 745   fail_unless (map.size == 100);
 746   gst_buffer_unmap (buf, &map);
 747
 748   fail_unless (gst_buffer_n_memory (buf) == 3);
 749
 750   gst_buffer_unref (buf);
 751
 752   /* map should merge */
 753   gst_buffer_map_range (buf, 1, 2, &map, GST_MAP_READ);
 754   /* merged memory is stored */
 755   fail_unless (gst_buffer_n_memory (buf) == 2);
 756   fail_unless (map.size == 100);
 757   gst_buffer_unmap (buf, &map);
 758
 759   fail_unless (gst_buffer_n_memory (buf) == 2);
 760
 761   /* should merge and store */
 762   gst_buffer_map (buf, &map, GST_MAP_READ);
 763   fail_unless (gst_buffer_n_memory (buf) == 1);
 764   gst_buffer_unmap (buf, &map);
 765
 766   gst_buffer_unref (buf);
 767 }
 768
 769 GST_END_TEST;
 770
 771 GST_START_TEST (test_find)
 772 {
 773   GstBuffer *buf;
 774   gsize maxalloc;
 775   gsize size, offset;
 776   guint idx, length;
 777
 778   buf = gst_buffer_new ();
 779   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 0, NULL));
 780   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 10, NULL));
 781   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 15, NULL));
 782   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 0, NULL));
 783
 784   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 785   fail_unless (size == 25);
 786   fail_unless (offset >= 0);
 787   fail_unless (maxalloc >= 25);
 788   fail_unless (gst_buffer_n_memory (buf) == 4);
 789
 790   fail_unless (gst_buffer_find_memory (buf, 0, 5, &idx, &length, &offset));
 791   fail_unless (idx == 1);
 792   fail_unless (length == 1);
 793   fail_unless (offset == 0);
 794
 795   fail_unless (gst_buffer_find_memory (buf, 0, 10, &idx, &length, &offset));
 796   fail_unless (idx == 1);
 797   fail_unless (length == 1);
 798   fail_unless (offset == 0);
 799
 800   fail_unless (gst_buffer_find_memory (buf, 5, 4, &idx, &length, &offset));
 801   fail_unless (idx == 1);
 802   fail_unless (length == 1);
 803   fail_unless (offset == 5);
 804
 805   fail_unless (gst_buffer_find_memory (buf, 5, 5, &idx, &length, &offset));
 806   fail_unless (idx == 1);
 807   fail_unless (length == 1);
 808   fail_unless (offset == 5);
 809
 810   fail_unless (gst_buffer_find_memory (buf, 5, 6, &idx, &length, &offset));
 811   fail_unless (idx == 1);
 812   fail_unless (length == 2);
 813   fail_unless (offset == 5);
 814
 815   fail_unless (gst_buffer_find_memory (buf, 10, 6, &idx, &length, &offset));
 816   fail_unless (idx == 2);
 817   fail_unless (length == 1);
 818   fail_unless (offset == 0);
 819
 820   fail_unless (gst_buffer_find_memory (buf, 10, 15, &idx, &length, &offset));
 821   fail_unless (idx == 2);
 822   fail_unless (length == 1);
 823   fail_unless (offset == 0);
 824
 825   fail_unless (gst_buffer_find_memory (buf, 11, 14, &idx, &length, &offset));
 826   fail_unless (idx == 2);
 827   fail_unless (length == 1);
 828   fail_unless (offset == 1);
 829
 830   fail_unless (gst_buffer_find_memory (buf, 0, 25, &idx, &length, &offset));
 831   fail_unless (idx == 1);
 832   fail_unless (length == 2);
 833   fail_unless (offset == 0);
 834
 835   fail_unless (gst_buffer_find_memory (buf, 24, 0, &idx, &length, &offset));
 836   fail_unless (idx == 2);
 837   fail_unless (length == 1);
 838   fail_unless (offset == 14);
 839
 840   fail_if (gst_buffer_find_memory (buf, 11, 15, &idx, &length, &offset));
 841   fail_if (gst_buffer_find_memory (buf, 0, 26, &idx, &length, &offset));
 842   fail_if (gst_buffer_find_memory (buf, 25, 0, &idx, &length, &offset));
 843
 844   fail_unless (gst_buffer_find_memory (buf, 1, -1, &idx, &length, &offset));
 845   fail_unless (idx == 1);
 846   fail_unless (length == 3);
 847   fail_unless (offset == 1);
 848
 849   gst_buffer_unref (buf);
 850 }
 851
 852 GST_END_TEST;
 853
 854 GST_START_TEST (test_fill)
 855 {
 856   GstBuffer *buf;
 857   guint8 data[1024], data2[25];
 858   gint i;
 859
 860   buf = gst_buffer_new ();
 861   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 0, NULL));
 862   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 10, NULL));
 863   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 15, NULL));
 864   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 0, NULL));
 865
 866   for (i = 0; i < G_N_ELEMENTS (data); ++i)
 867     data[i] = i & 0xff;
 868
 869   /* a NULL src pointer should be ok if the src length is 0 bytes */
 870   fail_unless_equals_int (gst_buffer_fill (buf, 0, NULL, 0), 0);
 871   fail_unless_equals_int (gst_buffer_fill (buf, 20, NULL, 0), 0);
 872   fail_unless_equals_int (gst_buffer_fill (buf, 0, data, 0), 0);
 873
 874   fail_unless_equals_int (gst_buffer_fill (buf, 0, data, 1), 1);
 875   fail_unless_equals_int (gst_buffer_fill (buf, 0, data, 11), 11);
 876   fail_unless_equals_int (gst_buffer_fill (buf, 0, data, 15), 15);
 877   fail_unless_equals_int (gst_buffer_fill (buf, 0, data, 25), 25);
 878   fail_unless_equals_int (gst_buffer_fill (buf, 0, data, 26), 25);
 879   fail_unless_equals_int (gst_buffer_fill (buf, 1, data, 26), 24);
 880   fail_unless_equals_int (gst_buffer_fill (buf, 10, data, 100), 15);
 881   fail_unless_equals_int (gst_buffer_fill (buf, 11, data, 100), 14);
 882   fail_unless_equals_int (gst_buffer_fill (buf, 25, data, 100), 0);
 883
 884   fail_unless_equals_int (gst_buffer_fill (buf, 0, data + 10, 25), 25);
 885   fail_unless_equals_int (gst_buffer_extract (buf, 0, data2, 25), 25);
 886   fail_unless (memcmp (data2, data + 10, 25) == 0);
 887
 888   gst_buffer_unref (buf);
 889 }
 890
 891 GST_END_TEST;
 892
 893 GST_START_TEST (test_parent_buffer_meta)
 894 {
 895   GstBuffer *buf, *parent;
 896   GstParentBufferMeta *meta;
 897
 898   buf = gst_buffer_new ();
 899   parent = gst_buffer_new ();
 900
 901   gst_buffer_add_parent_buffer_meta (buf, parent);
 902   meta = gst_buffer_get_parent_buffer_meta (buf);
 903   fail_unless (meta);
 904   fail_unless (parent == meta->buffer);
 905
 906   gst_buffer_unref (buf);
 907   gst_buffer_unref (parent);
 908 }
 909
 910 GST_END_TEST;
 911
 912
 913 static Suite *
 914 gst_buffer_suite (void)
 915 {
 916   Suite *s = suite_create ("GstBuffer");
 917   TCase *tc_chain = tcase_create ("general");
 918
 919   suite_add_tcase (s, tc_chain);
 920   tcase_add_test (tc_chain, test_subbuffer);
 921   tcase_add_test (tc_chain, test_subbuffer_make_writable);
 922   tcase_add_test (tc_chain, test_make_writable);
 923   tcase_add_test (tc_chain, test_span);
 924   tcase_add_test (tc_chain, test_metadata_writable);
 925   tcase_add_test (tc_chain, test_memcmp);
 926   tcase_add_test (tc_chain, test_copy);
 927   tcase_add_test (tc_chain, test_copy_deep);
 928   tcase_add_test (tc_chain, test_try_new_and_alloc);
 929   tcase_add_test (tc_chain, test_size);
 930   tcase_add_test (tc_chain, test_resize);
 931   tcase_add_test (tc_chain, test_map);
 932   tcase_add_test (tc_chain, test_map_range);
 933   tcase_add_test (tc_chain, test_find);
 934   tcase_add_test (tc_chain, test_fill);
 935   tcase_add_test (tc_chain, test_parent_buffer_meta);
 936
 937   return s;
 938 }
 939
 940 GST_CHECK_MAIN (gst_buffer);