tests/check/elements/fakesink.c

   1 /* GStreamer
   2  *
   3  * unit test for fakesink
   4  *
   5  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
   6  *               <2007> Wim Taymans <wim@fluendo.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <unistd.h>
  25
  26 #include <gst/check/gstcheck.h>
  27
  28 typedef struct
  29 {
  30   GstPad *pad;
  31   GstBuffer *buffer;
  32   GThread *thread;
  33   GstFlowReturn ret;
  34 } ChainData;
  35
  36 static gpointer
  37 chain_async_buffer (gpointer data)
  38 {
  39   ChainData *chain_data = (ChainData *) data;
  40
  41   chain_data->ret = gst_pad_chain (chain_data->pad, chain_data->buffer);
  42
  43   return chain_data;
  44 }
  45
  46 static ChainData *
  47 chain_async (GstPad * pad, GstBuffer * buffer)
  48 {
  49   GThread *thread;
  50   ChainData *chain_data;
  51   GError *error = NULL;
  52
  53   chain_data = g_new (ChainData, 1);
  54   chain_data->pad = pad;
  55   chain_data->buffer = buffer;
  56   chain_data->ret = GST_FLOW_ERROR;
  57
  58   thread = g_thread_create (chain_async_buffer, chain_data, TRUE, &error);
  59   if (error != NULL) {
  60     g_warning ("could not create thread reason: %s", error->message);
  61     g_free (chain_data);
  62     return NULL;
  63   }
  64   chain_data->thread = thread;
  65
  66   return chain_data;
  67 }
  68
  69 static GstFlowReturn
  70 chain_async_return (ChainData * data)
  71 {
  72   GstFlowReturn ret;
  73
  74   g_thread_join (data->thread);
  75   ret = data->ret;
  76   g_free (data);
  77
  78   return ret;
  79 }
  80
  81 GST_START_TEST (test_clipping)
  82 {
  83   GstElement *sink;
  84   GstPad *sinkpad;
  85   GstStateChangeReturn ret;
  86
  87   /* create sink */
  88   sink = gst_element_factory_make ("fakesink", "sink");
  89   fail_if (sink == NULL);
  90
  91   sinkpad = gst_element_get_pad (sink, "sink");
  92   fail_if (sinkpad == NULL);
  93
  94   /* make element ready to accept data */
  95   ret = gst_element_set_state (sink, GST_STATE_PAUSED);
  96   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
  97
  98   /* send segment */
  99   {
 100     GstEvent *segment;
 101     gboolean eret;
 102
 103     GST_DEBUG ("sending segment");
 104     segment = gst_event_new_new_segment (FALSE,
 105         1.0, GST_FORMAT_TIME, 1 * GST_SECOND, 5 * GST_SECOND, 1 * GST_SECOND);
 106
 107     eret = gst_pad_send_event (sinkpad, segment);
 108     fail_if (eret == FALSE);
 109   }
 110
 111   /* new segment should not have finished preroll */
 112   ret = gst_element_get_state (sink, NULL, NULL, 0);
 113   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 114
 115   /* send buffer that should be dropped */
 116   {
 117     GstBuffer *buffer;
 118     GstFlowReturn fret;
 119
 120     buffer = gst_buffer_new ();
 121     GST_BUFFER_TIMESTAMP (buffer) = 0;
 122     GST_BUFFER_DURATION (buffer) = 1 * GST_MSECOND;
 123
 124     GST_DEBUG ("sending buffer to be dropped");
 125     fret = gst_pad_chain (sinkpad, buffer);
 126     fail_if (fret != GST_FLOW_OK);
 127   }
 128   /* dropped buffer should not have finished preroll */
 129   ret = gst_element_get_state (sink, NULL, NULL, 0);
 130   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 131
 132   /* send buffer that should be dropped */
 133   {
 134     GstBuffer *buffer;
 135     GstFlowReturn fret;
 136
 137     buffer = gst_buffer_new ();
 138     GST_BUFFER_TIMESTAMP (buffer) = 5 * GST_SECOND;
 139     GST_BUFFER_DURATION (buffer) = 1 * GST_MSECOND;
 140
 141     GST_DEBUG ("sending buffer to be dropped");
 142     fret = gst_pad_chain (sinkpad, buffer);
 143     fail_if (fret != GST_FLOW_OK);
 144   }
 145   /* dropped buffer should not have finished preroll */
 146   ret = gst_element_get_state (sink, NULL, NULL, 0);
 147   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 148
 149   /* send buffer that should block and finish preroll */
 150   {
 151     GstBuffer *buffer;
 152     GstFlowReturn fret;
 153     ChainData *data;
 154     GstState current, pending;
 155
 156     buffer = gst_buffer_new ();
 157     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;
 158     GST_BUFFER_DURATION (buffer) = 1 * GST_MSECOND;
 159
 160     GST_DEBUG ("sending buffer to finish preroll");
 161     data = chain_async (sinkpad, buffer);
 162     fail_if (data == NULL);
 163
 164     /* state should now eventually change to PAUSED */
 165     ret = gst_element_get_state (sink, &current, &pending, GST_CLOCK_TIME_NONE);
 166     fail_unless (ret == GST_STATE_CHANGE_SUCCESS);
 167     fail_unless (current == GST_STATE_PAUSED);
 168     fail_unless (pending == GST_STATE_VOID_PENDING);
 169
 170     /* playing should render the buffer */
 171     ret = gst_element_set_state (sink, GST_STATE_PLAYING);
 172     fail_unless (ret == GST_STATE_CHANGE_SUCCESS);
 173
 174     /* and we should get a success return value */
 175     fret = chain_async_return (data);
 176     fail_if (fret != GST_FLOW_OK);
 177   }
 178
 179   /* send some buffer that will be dropped or clipped, this can
 180    * only be observed in the debug log. */
 181   {
 182     GstBuffer *buffer;
 183     GstFlowReturn fret;
 184
 185     buffer = gst_buffer_new ();
 186     GST_BUFFER_TIMESTAMP (buffer) = 6 * GST_SECOND;
 187     GST_BUFFER_DURATION (buffer) = 1 * GST_MSECOND;
 188
 189     /* should be dropped */
 190     GST_DEBUG ("sending buffer to drop");
 191     fret = gst_pad_chain (sinkpad, buffer);
 192     fail_if (fret != GST_FLOW_OK);
 193
 194     buffer = gst_buffer_new ();
 195     GST_BUFFER_TIMESTAMP (buffer) = 0 * GST_SECOND;
 196     GST_BUFFER_DURATION (buffer) = 2 * GST_SECOND;
 197
 198     /* should be clipped */
 199     GST_DEBUG ("sending buffer to clip");
 200     fret = gst_pad_chain (sinkpad, buffer);
 201     fail_if (fret != GST_FLOW_OK);
 202
 203     buffer = gst_buffer_new ();
 204     GST_BUFFER_TIMESTAMP (buffer) = 4 * GST_SECOND;
 205     GST_BUFFER_DURATION (buffer) = 2 * GST_SECOND;
 206
 207     /* should be clipped */
 208     GST_DEBUG ("sending buffer to clip");
 209     fret = gst_pad_chain (sinkpad, buffer);
 210     fail_if (fret != GST_FLOW_OK);
 211   }
 212
 213   gst_element_set_state (sink, GST_STATE_NULL);
 214   gst_element_get_state (sink, NULL, NULL, GST_CLOCK_TIME_NONE);
 215   gst_object_unref (sinkpad);
 216   gst_object_unref (sink);
 217 }
 218
 219 GST_END_TEST;
 220
 221 GST_START_TEST (test_preroll_sync)
 222 {
 223   GstElement *pipeline, *sink;
 224   GstPad *sinkpad;
 225   GstStateChangeReturn ret;
 226
 227   /* create sink */
 228   pipeline = gst_pipeline_new ("pipeline");
 229   fail_if (pipeline == NULL);
 230
 231   sink = gst_element_factory_make ("fakesink", "sink");
 232   fail_if (sink == NULL);
 233   g_object_set (G_OBJECT (sink), "sync", TRUE, NULL);
 234
 235   gst_bin_add (GST_BIN (pipeline), sink);
 236
 237   sinkpad = gst_element_get_pad (sink, "sink");
 238   fail_if (sinkpad == NULL);
 239
 240   /* make pipeline and element ready to accept data */
 241   ret = gst_element_set_state (pipeline, GST_STATE_PAUSED);
 242   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 243
 244   /* send segment */
 245   {
 246     GstEvent *segment;
 247     gboolean eret;
 248
 249     GST_DEBUG ("sending segment");
 250     segment = gst_event_new_new_segment (FALSE,
 251         1.0, GST_FORMAT_TIME, 0 * GST_SECOND, 2 * GST_SECOND, 0 * GST_SECOND);
 252
 253     eret = gst_pad_send_event (sinkpad, segment);
 254     fail_if (eret == FALSE);
 255   }
 256
 257   /* send buffer that should block and finish preroll */
 258   {
 259     GstBuffer *buffer;
 260     GstFlowReturn fret;
 261     ChainData *data;
 262     GstState current, pending;
 263
 264     buffer = gst_buffer_new ();
 265     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;
 266     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;
 267
 268     GST_DEBUG ("sending buffer to finish preroll");
 269     data = chain_async (sinkpad, buffer);
 270     fail_if (data == NULL);
 271
 272     /* state should now eventually change to PAUSED */
 273     ret =
 274         gst_element_get_state (pipeline, &current, &pending,
 275         GST_CLOCK_TIME_NONE);
 276     fail_unless (ret == GST_STATE_CHANGE_SUCCESS);
 277     fail_unless (current == GST_STATE_PAUSED);
 278     fail_unless (pending == GST_STATE_VOID_PENDING);
 279
 280     /* playing should render the buffer */
 281     ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
 282     fail_unless (ret == GST_STATE_CHANGE_SUCCESS);
 283
 284     /* and we should get a success return value */
 285     fret = chain_async_return (data);
 286     fail_if (fret != GST_FLOW_OK);
 287   }
 288   gst_element_set_state (pipeline, GST_STATE_NULL);
 289   gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 290   gst_object_unref (sinkpad);
 291   gst_object_unref (pipeline);
 292 }
 293
 294 GST_END_TEST;
 295
 296 /* after EOS, we refuse everything */
 297 GST_START_TEST (test_eos)
 298 {
 299   GstElement *pipeline, *sink;
 300   GstPad *sinkpad;
 301   GstStateChangeReturn ret;
 302   GstMessage *message;
 303   GstBus *bus;
 304
 305   /* create sink */
 306   pipeline = gst_pipeline_new ("pipeline");
 307   fail_if (pipeline == NULL);
 308
 309   bus = gst_pipeline_get_bus (GST_PIPELINE_CAST (pipeline));
 310   fail_if (bus == NULL);
 311
 312   sink = gst_element_factory_make ("fakesink", "sink");
 313   fail_if (sink == NULL);
 314   g_object_set (G_OBJECT (sink), "sync", TRUE, NULL);
 315
 316   gst_bin_add (GST_BIN (pipeline), sink);
 317
 318   sinkpad = gst_element_get_pad (sink, "sink");
 319   fail_if (sinkpad == NULL);
 320
 321   /* make pipeline and element ready to accept data */
 322   ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
 323   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 324
 325   /* send EOS, this should work fine */
 326   {
 327     GstEvent *eos;
 328     gboolean eret;
 329
 330     GST_DEBUG ("sending EOS");
 331     eos = gst_event_new_eos ();
 332
 333     eret = gst_pad_send_event (sinkpad, eos);
 334     fail_if (eret == FALSE);
 335   }
 336
 337   /* wait for preroll */
 338   gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 339
 340   /* EOS should be on the bus at some point */
 341   while (TRUE) {
 342     GstMessageType type;
 343
 344     /* blocking wait for messages */
 345     message = gst_bus_timed_pop (bus, GST_CLOCK_TIME_NONE);
 346     type = GST_MESSAGE_TYPE (message);
 347     gst_message_unref (message);
 348
 349     GST_DEBUG ("got message %s", gst_message_type_get_name (type));
 350
 351     if (type == GST_MESSAGE_EOS)
 352       break;
 353   }
 354   gst_object_unref (bus);
 355
 356   /* send another EOS, this should fail */
 357   {
 358     GstEvent *eos;
 359     gboolean eret;
 360
 361     GST_DEBUG ("sending second EOS");
 362     eos = gst_event_new_eos ();
 363
 364     eret = gst_pad_send_event (sinkpad, eos);
 365     fail_if (eret == TRUE);
 366   }
 367
 368   /* send segment, this should fail */
 369   {
 370     GstEvent *segment;
 371     gboolean eret;
 372
 373     GST_DEBUG ("sending segment");
 374     segment = gst_event_new_new_segment (FALSE,
 375         1.0, GST_FORMAT_TIME, 0 * GST_SECOND, 2 * GST_SECOND, 0 * GST_SECOND);
 376
 377     eret = gst_pad_send_event (sinkpad, segment);
 378     fail_if (eret == TRUE);
 379   }
 380
 381   /* send buffer that should fail after EOS */
 382   {
 383     GstBuffer *buffer;
 384     GstFlowReturn fret;
 385
 386     buffer = gst_buffer_new ();
 387     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;
 388     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;
 389
 390     GST_DEBUG ("sending buffer");
 391
 392     /* buffer after EOS is not UNEXPECTED */
 393     fret = gst_pad_chain (sinkpad, buffer);
 394     fail_unless (fret == GST_FLOW_UNEXPECTED);
 395   }
 396
 397   /* flush, EOS state is flushed again. */
 398   {
 399     GstEvent *event;
 400     gboolean eret;
 401
 402     GST_DEBUG ("sending FLUSH_START");
 403     event = gst_event_new_flush_start ();
 404     eret = gst_pad_send_event (sinkpad, event);
 405     fail_unless (eret == TRUE);
 406
 407     GST_DEBUG ("sending FLUSH_STOP");
 408     event = gst_event_new_flush_stop ();
 409     eret = gst_pad_send_event (sinkpad, event);
 410     fail_unless (eret == TRUE);
 411   }
 412
 413   /* send segment, this should now work again */
 414   {
 415     GstEvent *segment;
 416     gboolean eret;
 417
 418     GST_DEBUG ("sending segment");
 419     segment = gst_event_new_new_segment (FALSE,
 420         1.0, GST_FORMAT_TIME, 0 * GST_SECOND, 2 * GST_SECOND, 0 * GST_SECOND);
 421
 422     eret = gst_pad_send_event (sinkpad, segment);
 423     fail_unless (eret == TRUE);
 424   }
 425
 426   /* send buffer that should work and block */
 427   {
 428     GstBuffer *buffer;
 429     GstFlowReturn fret;
 430
 431     buffer = gst_buffer_new ();
 432     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;
 433     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;
 434
 435     GST_DEBUG ("sending buffer");
 436
 437     fret = gst_pad_chain (sinkpad, buffer);
 438     fail_unless (fret == GST_FLOW_OK);
 439   }
 440
 441   gst_element_set_state (pipeline, GST_STATE_NULL);
 442   gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 443   gst_object_unref (sinkpad);
 444   gst_object_unref (pipeline);
 445 }
 446
 447 GST_END_TEST;
 448
 449 /* test EOS triggered by the element */
 450 GST_START_TEST (test_eos2)
 451 {
 452   GstElement *pipeline, *sink;
 453   GstPad *sinkpad;
 454   GstStateChangeReturn ret;
 455
 456   /* create sink */
 457   pipeline = gst_pipeline_new ("pipeline");
 458   fail_if (pipeline == NULL);
 459
 460   sink = gst_element_factory_make ("fakesink", "sink");
 461   fail_if (sink == NULL);
 462   g_object_set (G_OBJECT (sink), "sync", TRUE, NULL);
 463   g_object_set (G_OBJECT (sink), "num-buffers", 1, NULL);
 464
 465   gst_bin_add (GST_BIN (pipeline), sink);
 466
 467   sinkpad = gst_element_get_pad (sink, "sink");
 468   fail_if (sinkpad == NULL);
 469
 470   /* make pipeline and element ready to accept data */
 471   ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
 472   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 473
 474   /* send segment, this should work */
 475   {
 476     GstEvent *segment;
 477     gboolean eret;
 478
 479     GST_DEBUG ("sending segment");
 480     segment = gst_event_new_new_segment (FALSE,
 481         1.0, GST_FORMAT_TIME, 0 * GST_SECOND, 2 * GST_SECOND, 0 * GST_SECOND);
 482
 483     eret = gst_pad_send_event (sinkpad, segment);
 484     fail_if (eret == FALSE);
 485   }
 486
 487   /* send buffer that should return UNEXPECTED */
 488   {
 489     GstBuffer *buffer;
 490     GstFlowReturn fret;
 491
 492     buffer = gst_buffer_new ();
 493     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;
 494     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;
 495
 496     GST_DEBUG ("sending buffer");
 497
 498     /* this buffer will generate UNEXPECTED */
 499     fret = gst_pad_chain (sinkpad, buffer);
 500     fail_unless (fret == GST_FLOW_UNEXPECTED);
 501   }
 502
 503   /* send buffer that should return UNEXPECTED */
 504   {
 505     GstBuffer *buffer;
 506     GstFlowReturn fret;
 507
 508     buffer = gst_buffer_new ();
 509     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;
 510     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;
 511
 512     GST_DEBUG ("sending buffer");
 513
 514     fret = gst_pad_chain (sinkpad, buffer);
 515     fail_unless (fret == GST_FLOW_UNEXPECTED);
 516   }
 517
 518   gst_element_set_state (pipeline, GST_STATE_NULL);
 519   gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 520   gst_object_unref (sinkpad);
 521   gst_object_unref (pipeline);
 522 }
 523
 524 GST_END_TEST;
 525
 526 static Suite *
 527 fakesink_suite (void)
 528 {
 529   Suite *s = suite_create ("fakesink");
 530   TCase *tc_chain = tcase_create ("general");
 531
 532   suite_add_tcase (s, tc_chain);
 533   tcase_add_test (tc_chain, test_clipping);
 534   tcase_add_test (tc_chain, test_preroll_sync);
 535   tcase_add_test (tc_chain, test_eos);
 536   tcase_add_test (tc_chain, test_eos2);
 537
 538   return s;
 539 }
 540
 541 GST_CHECK_MAIN (fakesink);