tests/check/elements/multifdsink.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2006 Thomas Vander Stichele <thomas at apestaart dot org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <unistd.h>
  22 #include <sys/ioctl.h>
  23 #ifdef HAVE_FIONREAD_IN_SYS_FILIO
  24 #include <sys/filio.h>
  25 #endif
  26
  27 #include <gst/check/gstcheck.h>
  28
  29 GstPad *mysrcpad;
  30
  31 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
  32     GST_PAD_SRC,
  33     GST_PAD_ALWAYS,
  34     GST_STATIC_CAPS ("application/x-gst-check")
  35     );
  36
  37 GstElement *
  38 setup_multifdsink ()
  39 {
  40   GstElement *multifdsink;
  41
  42   GST_DEBUG ("setup_multifdsink");
  43   multifdsink = gst_check_setup_element ("multifdsink");
  44   mysrcpad = gst_check_setup_src_pad (multifdsink, &srctemplate, NULL);
  45
  46   return multifdsink;
  47 }
  48
  49 void
  50 cleanup_multifdsink (GstElement * multifdsink)
  51 {
  52   GST_DEBUG ("cleanup_multifdsink");
  53
  54   gst_check_teardown_src_pad (multifdsink);
  55   gst_check_teardown_element (multifdsink);
  56 }
  57
  58 static void
  59 wait_bytes_served (GstElement * sink, guint64 bytes)
  60 {
  61   guint64 bytes_served = 0;
  62
  63   while (bytes_served != bytes) {
  64     g_object_get (sink, "bytes-served", &bytes_served, NULL);
  65   }
  66 }
  67
  68 /* FIXME: possibly racy, since if it would write, we may not get it
  69  * immediately ? */
  70 #define fail_if_can_read(msg,fd) \
  71 G_STMT_START { \
  72   long avail; \
  73 \
  74   fail_if (ioctl (fd, FIONREAD, &avail) < 0, "%s: could not ioctl", msg); \
  75   fail_if (avail > 0, "%s: has bytes available to read"); \
  76 } G_STMT_END;
  77
  78
  79 GST_START_TEST (test_no_clients)
  80 {
  81   GstElement *sink;
  82   GstBuffer *buffer;
  83   GstCaps *caps;
  84
  85   sink = setup_multifdsink ();
  86
  87   ASSERT_SET_STATE (sink, GST_STATE_PLAYING, GST_STATE_CHANGE_ASYNC);
  88
  89   caps = gst_caps_from_string ("application/x-gst-check");
  90   buffer = gst_buffer_new_and_alloc (4);
  91   gst_buffer_set_caps (buffer, caps);
  92   gst_caps_unref (caps);
  93   fail_unless (gst_pad_push (mysrcpad, buffer) == GST_FLOW_OK);
  94
  95   GST_DEBUG ("cleaning up multifdsink");
  96   ASSERT_SET_STATE (sink, GST_STATE_NULL, GST_STATE_CHANGE_SUCCESS);
  97   cleanup_multifdsink (sink);
  98 }
  99
 100 GST_END_TEST;
 101
 102 GST_START_TEST (test_add_client)
 103 {
 104   GstElement *sink;
 105   GstBuffer *buffer;
 106   GstCaps *caps;
 107   int pfd[2];
 108   gchar data[4];
 109   guint64 bytes_served;
 110
 111   sink = setup_multifdsink ();
 112
 113   fail_if (pipe (pfd) == -1);
 114
 115   ASSERT_SET_STATE (sink, GST_STATE_PLAYING, GST_STATE_CHANGE_ASYNC);
 116
 117   /* add the client */
 118   g_signal_emit_by_name (sink, "add", pfd[1]);
 119
 120   caps = gst_caps_from_string ("application/x-gst-check");
 121   buffer = gst_buffer_new_and_alloc (4);
 122   gst_buffer_set_caps (buffer, caps);
 123   gst_caps_unref (caps);
 124   memcpy (GST_BUFFER_DATA (buffer), "dead", 4);
 125   fail_unless (gst_pad_push (mysrcpad, buffer) == GST_FLOW_OK);
 126
 127   fail_if (read (pfd[0], data, 4) < 4);
 128   fail_unless (strncmp (data, "dead", 4) == 0);
 129   wait_bytes_served (sink, 4);
 130
 131   GST_DEBUG ("cleaning up multifdsink");
 132   ASSERT_SET_STATE (sink, GST_STATE_NULL, GST_STATE_CHANGE_SUCCESS);
 133   cleanup_multifdsink (sink);
 134 }
 135
 136 GST_END_TEST;
 137
 138 #define fail_unless_read(msg,fd,size,ref) \
 139 G_STMT_START { \
 140   char data[size + 1]; \
 141   int nbytes; \
 142 \
 143   GST_DEBUG ("%s: reading %d bytes", msg, size); \
 144   nbytes = read (fd, data, size); \
 145   data[size] = 0; \
 146   GST_DEBUG ("%s: read %d bytes", msg, nbytes); \
 147   fail_if (nbytes < size); \
 148   fail_unless (memcmp (data, ref, size) == 0, \
 149       "data read '%s' differs from '%s'", data, ref); \
 150 } G_STMT_END;
 151
 152 /* from the given two data buffers, create two streamheader buffers and
 153  * some caps that match it, and store them in the given pointers
 154  * returns buffers and caps with a refcount of 1 */
 155 static void
 156 gst_multifdsink_create_streamheader (const gchar * data1,
 157     const gchar * data2, GstBuffer ** hbuf1, GstBuffer ** hbuf2,
 158     GstCaps ** caps)
 159 {
 160   GValue array = { 0 };
 161   GValue value = { 0 };
 162   GstStructure *structure;
 163   guint size1 = strlen (data1);
 164   guint size2 = strlen (data2);
 165
 166   fail_if (hbuf1 == NULL);
 167   fail_if (hbuf2 == NULL);
 168   fail_if (caps == NULL);
 169
 170   /* create caps with streamheader, set the caps, and push the IN_CAPS
 171    * buffers */
 172   *hbuf1 = gst_buffer_new_and_alloc (size1);
 173   GST_BUFFER_FLAG_SET (*hbuf1, GST_BUFFER_FLAG_IN_CAPS);
 174   memcpy (GST_BUFFER_DATA (*hbuf1), data1, size1);
 175   *hbuf2 = gst_buffer_new_and_alloc (size2);
 176   GST_BUFFER_FLAG_SET (*hbuf2, GST_BUFFER_FLAG_IN_CAPS);
 177   memcpy (GST_BUFFER_DATA (*hbuf2), data2, size2);
 178   /* we want to keep them around for the tests */
 179   gst_buffer_ref (*hbuf1);
 180   gst_buffer_ref (*hbuf2);
 181
 182   g_value_init (&array, GST_TYPE_ARRAY);
 183
 184   g_value_init (&value, GST_TYPE_BUFFER);
 185   gst_value_set_buffer (&value, *hbuf1);
 186   gst_value_array_append_value (&array, &value);
 187   g_value_unset (&value);
 188
 189   g_value_init (&value, GST_TYPE_BUFFER);
 190   gst_value_set_buffer (&value, *hbuf2);
 191   gst_value_array_append_value (&array, &value);
 192   g_value_unset (&value);
 193
 194   *caps = gst_caps_from_string ("application/x-gst-check");
 195   structure = gst_caps_get_structure (*caps, 0);
 196
 197   gst_structure_set_value (structure, "streamheader", &array);
 198   g_value_unset (&array);
 199
 200   /* set our streamheadery caps on the buffers */
 201   gst_buffer_set_caps (*hbuf1, *caps);
 202   gst_buffer_set_caps (*hbuf2, *caps);
 203
 204   GST_DEBUG ("created streamheader caps %" GST_PTR_FORMAT, *caps);
 205 }
 206
 207
 208 /* this test:
 209  * - adds a first client
 210  * - sets streamheader caps on the pad
 211  * - pushes the IN_CAPS buffers
 212  * - pushes a buffer
 213  * - verifies that the client received all the data correctly
 214  * - adds a second client
 215  * - verifies that this second client receives the streamheader caps too, plus
 216  * - the new buffer
 217  */
 218 GST_START_TEST (test_streamheader)
 219 {
 220   GstElement *sink;
 221   GstBuffer *hbuf1, *hbuf2, *buf;
 222   GstCaps *caps;
 223   GstStructure *structure;
 224   int pfd1[2], pfd2[2];
 225   guint8 data[12];
 226   guint64 bytes_served;
 227   int avail;
 228
 229   sink = setup_multifdsink ();
 230
 231   fail_if (pipe (pfd1) == -1);
 232   fail_if (pipe (pfd2) == -1);
 233
 234   ASSERT_SET_STATE (sink, GST_STATE_PLAYING, GST_STATE_CHANGE_ASYNC);
 235
 236   /* add the first client */
 237   g_signal_emit_by_name (sink, "add", pfd1[1]);
 238
 239   /* create caps with streamheader, set the caps, and push the IN_CAPS
 240    * buffers */
 241   gst_multifdsink_create_streamheader ("babe", "deadbeef", &hbuf1, &hbuf2,
 242       &caps);
 243   fail_unless (gst_pad_set_caps (mysrcpad, caps));
 244   gst_caps_unref (caps);
 245
 246   fail_unless (gst_pad_push (mysrcpad, hbuf1) == GST_FLOW_OK);
 247   fail_unless (gst_pad_push (mysrcpad, hbuf2) == GST_FLOW_OK);
 248
 249   //FIXME:
 250   //fail_if_can_read ("first client", pfd1[0]);
 251
 252   /* push a non-IN_CAPS buffer, this should trigger the client receiving the
 253    * first three buffers */
 254   buf = gst_buffer_new_and_alloc (4);
 255   memcpy (GST_BUFFER_DATA (buf), "f00d", 4);
 256   gst_pad_push (mysrcpad, buf);
 257
 258   fail_unless_read ("first client", pfd1[0], 4, "babe");
 259   fail_unless_read ("first client", pfd1[0], 8, "deadbeef");
 260   fail_unless_read ("first client", pfd1[0], 4, "f00d");
 261   wait_bytes_served (sink, 16);
 262
 263   /* now add the second client */
 264   g_signal_emit_by_name (sink, "add", pfd2[1]);
 265   //FIXME:
 266   //fail_if_can_read ("second client", pfd2[0]);
 267
 268   /* now push another buffer, which will trigger streamheader for second
 269    * client */
 270   buf = gst_buffer_new_and_alloc (4);
 271   memcpy (GST_BUFFER_DATA (buf), "deaf", 4);
 272   gst_pad_push (mysrcpad, buf);
 273
 274   fail_unless_read ("first client", pfd1[0], 4, "deaf");
 275
 276   fail_unless_read ("second client", pfd2[0], 4, "babe");
 277   fail_unless_read ("second client", pfd2[0], 8, "deadbeef");
 278   /* we missed the f00d buffer */
 279   fail_unless_read ("second client", pfd2[0], 4, "deaf");
 280   wait_bytes_served (sink, 36);
 281
 282   gst_buffer_unref (hbuf1);
 283   gst_buffer_unref (hbuf2);
 284   GST_DEBUG ("cleaning up multifdsink");
 285   ASSERT_SET_STATE (sink, GST_STATE_NULL, GST_STATE_CHANGE_SUCCESS);
 286   cleanup_multifdsink (sink);
 287 }
 288
 289 GST_END_TEST;
 290
 291 /* this tests changing of streamheaders
 292  * - set streamheader caps on the pad
 293  * - pushes the IN_CAPS buffers
 294  * - pushes a buffer
 295  * - add a first client
 296  * - verifies that this first client receives the first streamheader caps,
 297  *   plus a new buffer
 298  * - change streamheader caps
 299  * - verify that the first client receives the new streamheader buffers as well
 300  */
 301 GST_START_TEST (test_change_streamheader)
 302 {
 303   GstElement *sink;
 304   GstBuffer *hbuf1, *hbuf2, *buf;
 305   GstCaps *caps;
 306   GstStructure *structure;
 307   int pfd1[2], pfd2[2];
 308   guint8 data[12];
 309   GValue array = { 0 };
 310   GValue value = { 0 };
 311   guint64 bytes_served;
 312   int avail;
 313
 314   sink = setup_multifdsink ();
 315
 316   fail_if (pipe (pfd1) == -1);
 317   fail_if (pipe (pfd2) == -1);
 318
 319   ASSERT_SET_STATE (sink, GST_STATE_PLAYING, GST_STATE_CHANGE_ASYNC);
 320
 321   /* create caps with streamheader, set the caps, and push the IN_CAPS
 322    * buffers */
 323   gst_multifdsink_create_streamheader ("first", "header", &hbuf1, &hbuf2,
 324       &caps);
 325   fail_unless (gst_pad_set_caps (mysrcpad, caps));
 326   gst_caps_unref (caps);
 327
 328   fail_unless (gst_pad_push (mysrcpad, hbuf1) == GST_FLOW_OK);
 329   fail_unless (gst_pad_push (mysrcpad, hbuf2) == GST_FLOW_OK);
 330
 331   /* add the first client */
 332   g_signal_emit_by_name (sink, "add", pfd1[1]);
 333
 334   /* verify this hasn't triggered a write yet */
 335   /* FIXME: possibly racy, since if it would write, we may not get it
 336    * immediately ? */
 337   fail_if_can_read ("first client, no buffer", pfd1[0]);
 338
 339   /* now push a buffer and read */
 340   buf = gst_buffer_new_and_alloc (4);
 341   memcpy (GST_BUFFER_DATA (buf), "f00d", 4);
 342   gst_pad_push (mysrcpad, buf);
 343
 344   fail_unless_read ("change: first client", pfd1[0], 5, "first");
 345   fail_unless_read ("change: first client", pfd1[0], 6, "header");
 346   fail_unless_read ("change: first client", pfd1[0], 4, "f00d");
 347   //wait_bytes_served (sink, 16);
 348
 349   /* now add the second client */
 350   g_signal_emit_by_name (sink, "add", pfd2[1]);
 351   fail_if_can_read ("second client, no buffer", pfd2[0]);
 352
 353   /* change the streamheader */
 354   gst_buffer_unref (hbuf1);
 355   gst_buffer_unref (hbuf2);
 356   gst_multifdsink_create_streamheader ("second", "header", &hbuf1, &hbuf2,
 357       &caps);
 358   fail_unless (gst_pad_set_caps (mysrcpad, caps));
 359   gst_caps_unref (caps);
 360
 361   fail_unless (gst_pad_push (mysrcpad, hbuf1) == GST_FLOW_OK);
 362   fail_unless (gst_pad_push (mysrcpad, hbuf2) == GST_FLOW_OK);
 363
 364   /* verify neither client has new data available to read */
 365   fail_if_can_read ("first client, changed streamheader", pfd1[0]);
 366   fail_if_can_read ("second client, changed streamheader", pfd2[0]);
 367
 368   /* now push another buffer, which will trigger streamheader for second
 369    * client, but should also send new streamheaders to first client */
 370   buf = gst_buffer_new_and_alloc (8);
 371   memcpy (GST_BUFFER_DATA (buf), "deadbabe", 8);
 372   gst_pad_push (mysrcpad, buf);
 373
 374   fail_unless_read ("first client", pfd1[0], 6, "second");
 375   fail_unless_read ("first client", pfd1[0], 6, "header");
 376   fail_unless_read ("first client", pfd1[0], 8, "deadbabe");
 377
 378   /* new streamheader data */
 379   fail_unless_read ("second client", pfd2[0], 6, "second");
 380   fail_unless_read ("second client", pfd2[0], 6, "header");
 381   /* we missed the f00d buffer */
 382   fail_unless_read ("second client", pfd2[0], 8, "deadbabe");
 383   //wait_bytes_served (sink, 36);
 384
 385   gst_buffer_unref (hbuf1);
 386   gst_buffer_unref (hbuf2);
 387   GST_DEBUG ("cleaning up multifdsink");
 388   ASSERT_SET_STATE (sink, GST_STATE_NULL, GST_STATE_CHANGE_SUCCESS);
 389   cleanup_multifdsink (sink);
 390 }
 391
 392 GST_END_TEST;
 393
 394 /* FIXME: add test simulating chained oggs where:
 395  * sync-method is burst-on-connect
 396  * (when multifdsink actually does burst-on-connect based on byte size, not
 397    "last keyframe" which any frame for audio :))
 398  * an old client still needs to read from before the new streamheaders
 399  * a new client gets the new streamheaders
 400  */
 401
 402 Suite *
 403 multifdsink_suite (void)
 404 {
 405   Suite *s = suite_create ("multifdsink");
 406   TCase *tc_chain = tcase_create ("general");
 407
 408   suite_add_tcase (s, tc_chain);
 409 //  tcase_add_test (tc_chain, test_no_clients);
 410 //  tcase_add_test (tc_chain, test_add_client);
 411 //  tcase_add_test (tc_chain, test_streamheader);
 412   tcase_add_test (tc_chain, test_change_streamheader);
 413
 414   return s;
 415 }
 416
 417 int
 418 main (int argc, char **argv)
 419 {
 420   int nf;
 421
 422   Suite *s = multifdsink_suite ();
 423   SRunner *sr = srunner_create (s);
 424
 425   gst_check_init (&argc, &argv);
 426
 427   srunner_run_all (sr, CK_NORMAL);
 428   nf = srunner_ntests_failed (sr);
 429   srunner_free (sr);
 430
 431   return nf;
 432 }