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., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <gst/check/gstcheck.h>
  24
  25 GST_START_TEST (test_caps)
  26 {
  27   GstBuffer *buffer;
  28   GstCaps *caps, *caps2;
  29
  30   buffer = gst_buffer_new_and_alloc (4);
  31   caps = gst_caps_from_string ("audio/x-raw-int");
  32   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
  33
  34   fail_unless (GST_BUFFER_CAPS (buffer) == NULL);
  35
  36   gst_buffer_set_caps (buffer, caps);
  37   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
  38
  39   fail_unless (GST_BUFFER_CAPS (buffer) == caps);
  40   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
  41
  42   caps2 = gst_caps_from_string ("audio/x-raw-float");
  43   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 1);
  44
  45   gst_buffer_set_caps (buffer, caps2);
  46   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
  47   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 2);
  48
  49   gst_buffer_set_caps (buffer, NULL);
  50   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
  51   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 1);
  52
  53   /* clean up, with caps2 still set as caps */
  54   gst_buffer_set_caps (buffer, caps2);
  55   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 2);
  56   gst_buffer_unref (buffer);
  57   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 1);
  58   gst_caps_unref (caps);
  59   gst_caps_unref (caps2);
  60 }
  61
  62 GST_END_TEST;
  63
  64
  65 GST_START_TEST (test_subbuffer)
  66 {
  67   GstBuffer *buffer, *sub;
  68
  69   buffer = gst_buffer_new_and_alloc (4);
  70   memset (GST_BUFFER_DATA (buffer), 0, 4);
  71
  72   sub = gst_buffer_create_sub (buffer, 1, 2);
  73   fail_if (sub == NULL, "create_sub of buffer returned NULL");
  74   fail_unless (GST_BUFFER_SIZE (sub) == 2, "subbuffer has wrong size");
  75   fail_unless (memcmp (GST_BUFFER_DATA (buffer) + 1, GST_BUFFER_DATA (sub),
  76           2) == 0, "subbuffer contains the wrong data");
  77   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
  78   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
  79
  80   /* clean up */
  81   gst_buffer_unref (sub);
  82   gst_buffer_unref (buffer);
  83 }
  84
  85 GST_END_TEST;
  86
  87 GST_START_TEST (test_is_span_fast)
  88 {
  89   GstBuffer *buffer, *sub1, *sub2;
  90
  91   buffer = gst_buffer_new_and_alloc (4);
  92
  93   sub1 = gst_buffer_create_sub (buffer, 0, 2);
  94   fail_if (sub1 == NULL, "create_sub of buffer returned NULL");
  95
  96   sub2 = gst_buffer_create_sub (buffer, 2, 2);
  97   fail_if (sub2 == NULL, "create_sub of buffer returned NULL");
  98
  99   fail_if (gst_buffer_is_span_fast (buffer, sub2) == TRUE,
 100       "a parent buffer can't be span_fasted");
 101
 102   fail_if (gst_buffer_is_span_fast (sub1, buffer) == TRUE,
 103       "a parent buffer can't be span_fasted");
 104
 105   fail_if (gst_buffer_is_span_fast (sub1, sub2) == FALSE,
 106       "two subbuffers next to each other should be span_fast");
 107
 108   /* clean up */
 109   gst_buffer_unref (sub1);
 110   gst_buffer_unref (sub2);
 111   gst_buffer_unref (buffer);
 112 }
 113
 114 GST_END_TEST;
 115
 116 GST_START_TEST (test_span)
 117 {
 118   GstBuffer *buffer, *sub1, *sub2, *span;
 119
 120   buffer = gst_buffer_new_and_alloc (4);
 121   memcpy (GST_BUFFER_DATA (buffer), "data", 4);
 122
 123   ASSERT_CRITICAL (gst_buffer_span (NULL, 1, NULL, 2));
 124   ASSERT_CRITICAL (gst_buffer_span (buffer, 1, NULL, 2));
 125   ASSERT_CRITICAL (gst_buffer_span (NULL, 1, buffer, 2));
 126   ASSERT_CRITICAL (gst_buffer_span (buffer, 0, buffer, 10));
 127
 128   sub1 = gst_buffer_create_sub (buffer, 0, 2);
 129   fail_if (sub1 == NULL, "create_sub of buffer returned NULL");
 130
 131   sub2 = gst_buffer_create_sub (buffer, 2, 2);
 132   fail_if (sub2 == NULL, "create_sub of buffer returned NULL");
 133
 134   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 135   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 136   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 137
 138   /* span will create a new subbuffer from the parent */
 139   span = gst_buffer_span (sub1, 0, sub2, 4);
 140   fail_unless (GST_BUFFER_SIZE (span) == 4, "spanned buffer is wrong size");
 141   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 4);
 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 (GST_BUFFER_DATA (span), "data", 4) == 0,
 146       "spanned buffer contains the wrong data");
 147   gst_buffer_unref (span);
 148   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 149
 150   /* span from non-contiguous buffers will create new buffers */
 151   span = gst_buffer_span (sub2, 0, sub1, 4);
 152   fail_unless (GST_BUFFER_SIZE (span) == 4, "spanned buffer is wrong size");
 153   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 154   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 155   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 156   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 157   fail_unless (memcmp (GST_BUFFER_DATA (span), "tada", 4) == 0,
 158       "spanned buffer contains the wrong data");
 159   gst_buffer_unref (span);
 160   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 161
 162   /* span with different sizes */
 163   span = gst_buffer_span (sub1, 1, sub2, 3);
 164   fail_unless (GST_BUFFER_SIZE (span) == 3, "spanned buffer is wrong size");
 165   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 4);
 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 (GST_BUFFER_DATA (span), "ata", 3) == 0,
 170       "spanned buffer contains the wrong data");
 171   gst_buffer_unref (span);
 172   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 173
 174   span = gst_buffer_span (sub2, 0, sub1, 3);
 175   fail_unless (GST_BUFFER_SIZE (span) == 3, "spanned buffer is wrong size");
 176   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 177   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 178   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 179   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 180   fail_unless (memcmp (GST_BUFFER_DATA (span), "tad", 3) == 0,
 181       "spanned buffer contains the wrong data");
 182   gst_buffer_unref (span);
 183   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 184
 185 /* clean up */
 186   gst_buffer_unref (sub1);
 187   gst_buffer_unref (sub2);
 188   gst_buffer_unref (buffer);
 189 }
 190
 191 GST_END_TEST;
 192
 193
 194 static const char ro_memory[] = "abcdefghijklmnopqrstuvwxyz";
 195
 196 static GstBuffer *
 197 create_read_only_buffer (void)
 198 {
 199   GstBuffer *buf;
 200
 201   buf = (GstBuffer *) gst_mini_object_new (GST_TYPE_BUFFER);
 202
 203   /* assign some read-only data to the new buffer */
 204   GST_BUFFER_DATA (buf) = (guint8 *) ro_memory;
 205   GST_BUFFER_SIZE (buf) = sizeof (ro_memory);
 206
 207   GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);
 208
 209   return buf;
 210 }
 211
 212 GST_START_TEST (test_make_writable)
 213 {
 214   GstBuffer *buf, *buf2;
 215
 216   /* create read-only buffer and make it writable */
 217   buf = create_read_only_buffer ();
 218   fail_unless (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 219       "read-only buffer should have read-only flag set");
 220   buf = gst_buffer_make_writable (buf);
 221   fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 222       "writable buffer must not have read-only flag set");
 223   GST_BUFFER_DATA (buf)[4] = 'a';
 224   gst_buffer_unref (buf);
 225
 226   /* alloc'ed buffer with refcount 1 should be writable */
 227   buf = gst_buffer_new_and_alloc (32);
 228   fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 229       "_new_and_alloc'ed buffer must not have read-only flag set");
 230   buf2 = gst_buffer_make_writable (buf);
 231   fail_unless (buf == buf2,
 232       "_make_writable() should have returned same buffer");
 233   gst_buffer_unref (buf2);
 234
 235   /* alloc'ed buffer with refcount >1 should be copied */
 236   buf = gst_buffer_new_and_alloc (32);
 237   fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 238       "_new_and_alloc'ed buffer must not have read-only flag set");
 239   gst_buffer_ref (buf);
 240   buf2 = gst_buffer_make_writable (buf);
 241   fail_unless (buf != buf2, "_make_writable() should have returned a copy!");
 242   gst_buffer_unref (buf2);
 243   gst_buffer_unref (buf);
 244 }
 245
 246 GST_END_TEST;
 247
 248 GST_START_TEST (test_subbuffer_make_writable)
 249 {
 250   GstBuffer *buf, *sub_buf;
 251
 252   /* create sub-buffer of read-only buffer and make it writable */
 253   buf = create_read_only_buffer ();
 254   fail_unless (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 255       "read-only buffer should have read-only flag set");
 256
 257   sub_buf = gst_buffer_create_sub (buf, 0, 8);
 258   fail_unless (GST_BUFFER_FLAG_IS_SET (sub_buf, GST_BUFFER_FLAG_READONLY),
 259       "sub-buffer of read-only buffer should have read-only flag set");
 260
 261   sub_buf = gst_buffer_make_writable (sub_buf);
 262   fail_unless (!GST_BUFFER_FLAG_IS_SET (sub_buf, GST_BUFFER_FLAG_READONLY),
 263       "writable buffer must not have read-only flag set");
 264   GST_BUFFER_DATA (sub_buf)[4] = 'a';
 265   gst_buffer_unref (sub_buf);
 266   gst_buffer_unref (buf);
 267 }
 268
 269 GST_END_TEST;
 270
 271 GST_START_TEST (test_metadata_writable)
 272 {
 273   GstBuffer *buffer, *sub1;
 274
 275   buffer = gst_buffer_new_and_alloc (4);
 276   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
 277   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
 278
 279   /* Buffer with refcount 1 should have writable metadata */
 280   fail_unless (gst_buffer_is_metadata_writable (buffer) == TRUE);
 281
 282   /* Check that a buffer with refcount 2 does not have writable metadata */
 283   gst_buffer_ref (buffer);
 284   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2);
 285   fail_unless (gst_buffer_is_metadata_writable (buffer) == FALSE);
 286
 287   /* Check that make_metadata_writable produces a new sub-buffer with
 288    * writable metadata. */
 289   sub1 = gst_buffer_make_metadata_writable (buffer);
 290   fail_if (sub1 == buffer);
 291   fail_unless (gst_buffer_is_metadata_writable (sub1) == TRUE);
 292
 293   /* Check that the original metadata is still not writable
 294    * (subbuffer should be holding a reference, and so should we) */
 295   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2);
 296   fail_unless (gst_buffer_is_metadata_writable (buffer) == FALSE);
 297
 298   /* Check that make_metadata_writable() maintains the buffer flags */
 299   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DISCONT));
 300   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DELTA_UNIT));
 301
 302   /* Unset flags on writable buffer, then make sure they're still
 303    * set on the original buffer */
 304   GST_BUFFER_FLAG_UNSET (sub1, GST_BUFFER_FLAG_DISCONT);
 305   GST_BUFFER_FLAG_UNSET (sub1, GST_BUFFER_FLAG_DELTA_UNIT);
 306   fail_unless (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT));
 307   fail_unless (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT));
 308
 309   /* Drop the subbuffer and check that the metadata is now writable again */
 310   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 311   gst_buffer_unref (sub1);
 312   fail_unless (gst_buffer_is_metadata_writable (buffer) == TRUE);
 313
 314   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 315   gst_buffer_unref (buffer);
 316 }
 317
 318 GST_END_TEST;
 319
 320 Suite *
 321 gst_buffer_suite (void)
 322 {
 323   Suite *s = suite_create ("GstBuffer");
 324   TCase *tc_chain = tcase_create ("general");
 325
 326   suite_add_tcase (s, tc_chain);
 327   tcase_add_test (tc_chain, test_caps);
 328   tcase_add_test (tc_chain, test_subbuffer);
 329   tcase_add_test (tc_chain, test_subbuffer_make_writable);
 330   tcase_add_test (tc_chain, test_make_writable);
 331   tcase_add_test (tc_chain, test_is_span_fast);
 332   tcase_add_test (tc_chain, test_span);
 333   tcase_add_test (tc_chain, test_metadata_writable);
 334   return s;
 335 }
 336
 337 GST_CHECK_MAIN (gst_buffer);