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